wine Documentation

Official C developer resources and documentation for wine-mirror/wine with 4.3k stars. Verified technical context for AI.

4,263 stars C C 18 files · ~24,970 tokens
RAW Doc

Technical Documentation: wine-mirror/wine

ℹ️ Provenance: Multi-Tier Ingestion · CodeWiki Reference

Overview (README.md)

INTRODUCTION

Wine is a program which allows running Microsoft Windows programs
(including DOS, Windows 3.x, Win32, and Win64 executables) on Unix.
It consists of a program loader which loads and executes a Microsoft
Windows binary, and a library (called Winelib) that implements Windows
API calls using their Unix, X11 or Mac equivalents. The library may also
be used for porting Windows code into native Unix executables.

Wine is free software, released under the GNU LGPL; see the file
LICENSE for the details.

QUICK START

From the top-level directory of the Wine source (which contains this file),
run:

text
./configure
make

Then either install Wine:

text
make install

Or run Wine directly from the build directory:

text
./wine notepad

Run programs as wine program. For more information and problem
resolution, read the rest of this file, the Wine man page, and
especially the wealth of information found at https://www.winehq.org.

REQUIREMENTS

To compile and run Wine, you must have one of the following:

  • Linux version 2.6.22 or later
  • FreeBSD 12.4 or later
  • Solaris x86 9 or later
  • NetBSD-current
  • macOS 10.15 or later

As Wine requires kernel-level thread support to run, only the operating
systems mentioned above are supported. Other operating systems which
support kernel threads may be supported in the future.

FreeBSD info:
See https://wiki.freebsd.org/Wine for more information.

Solaris info:
You will most likely need to build Wine with the GNU toolchain
(gcc, gas, etc.). Warning : installing gas does not ensure that it
will be used by gcc. Recompiling gcc after installing gas or
symlinking cc, as and ld to the gnu tools is said to be necessary.

NetBSD info:
Make sure you have the USER_LDT, SYSVSHM, SYSVSEM, and SYSVMSG options
turned on in your kernel.

macOS info:
You need Xcode/Xcode Command Line Tools or Apple cctools.

Supported file systems:
Wine should run on most file systems. A few compatibility problems
have also been reported using files accessed through Samba. Also,
NTFS does not provide all the file system features needed by some
applications. Using a native Unix file system is recommended.

Basic requirements:
You need to have the X11 development include files installed
(called xorg-dev in Debian and libX11-devel in Red Hat).
Of course you also need make (most likely GNU make).
You also need flex version 2.5.33 or later and bison.

Optional support libraries:
Configure will display notices when optional libraries are not found
on your system. See https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine
for hints about the packages you should install. On 64-bit
platforms, you have to make sure to install the 32-bit versions of
these libraries.

COMPILATION

To build Wine, do:

text
./configure
make

This will build the program "wine" and numerous support libraries/binaries.
The program "wine" will load and run Windows executables.
The library "libwine" ("Winelib") can be used to compile and link
Windows source code under Unix.

To see compile configuration options, do ./configure --help.

For more information, see https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

SETUP

Once Wine has been built correctly, you can do make install; this
will install the wine executable and libraries, the Wine man page, and
other needed files.

Don't forget to uninstall any conflicting previous Wine installation
first. Try either dpkg -r wine or rpm -e wine or make uninstall
before installing.

Once installed, you can run the winecfg configuration tool. See the
Support area at https://www.winehq.org/ for configuration hints.

RUNNING PROGRAMS

When invoking Wine, you may specify the entire path to the executable,
or a filename only.

For example, to run Notepad:

text
wine notepad            (using the search Path as specified in
wine notepad.exe         the registry to locate the file)

wine c:\\windows\\notepad.exe      (using DOS filename syntax)

wine ~/.wine/drive_c/windows/notepad.exe  (using Unix filename syntax)

wine notepad.exe readme.txt          (calling program with parameters)

Wine is not perfect, so some programs may crash. If that happens you
will get a crash log that you should attach to your report when filing
a bug.

GETTING MORE INFORMATION

Documentation README De (`documentation/README-de.md`)

EINFÜHRUNG

Wine ist ein Programm, das es ermöglicht, Programme, die für Microsoft
Windows geschrieben wurden (inklusive DOS-, Windows 3.x-, Win32- und
Win64-Binärdateien), unter Unix auszuführen. Es besteht aus einem Programm-
Lader, der Microsoft-Windows-Binärdateien lädt und ausführt, sowie
einer Programmbibliothek (Winelib genannt), die Aufrufe der Windows API unter
Verwendung der entsprechenden Unix- oder X11-Gegenstücke implementiert.
Winelib kann auch benutzt werden, um Windows-Code nativ nach Unix
zu portieren.

Wine ist Freie Software, die unter der GNU LGPL veröffentlicht wird;
Bitte lesen Sie die Details in der Datei LICENSE nach.

SCHNELLSTART

Rufen Sie aus dem Stammverzeichnis des Wine-Quelltextes (das die Datei README
enthält) folgende Befehle auf:

text
./configure
make

Im Anschluss können Sie Wine entweder installieren:

text
make install

Oder direkt aus dem Quellverzeichnis ausführen:

text
./wine notepad

Starten Sie Programme mit wine Programmname. Weitere
Informationen und Problemlösungen entnehmen Sie bitte dem Rest dieser
Datei, der Man-Page von Wine und insbesondere der Vielzahl an
Informationen, die Sie auf https://www.winehq.org finden.

VORAUSSETZUNGEN

Um Wine kompilieren und ausführen zu können, benötigen Sie eines der
folgenden Betriebssysteme:

  • Linux version 2.6.22 oder neuer
  • FreeBSD 12.4 oder neuer
  • Solaris x86 9 oder neuer
  • NetBSD-current
  • macOS 10.15 oder neuer

Da Wine Thread-Unterstützung auf Kernelebene benötigt, werden nur die oben
aufgeführten Betriebssysteme unterstützt.
Andere Betriebssysteme, die Kernel-Threads unterstützen, werden unter
Umständen in der Zukunft unterstützt.

FreeBSD-Info:
Wine wird generell nicht korrekt unter FreeBSD vor 8.0 funktionieren. Für
weitere Informationen überprüfen Sie auch https://wiki.freebsd.org/Wine

Solaris-Info:
Höchstwahrscheinlich werden Sie Wine mit der GNU-Toolchain (gcc, gas etc.)
kompilieren müssen. Warnung: Die Installation von gas stellt nicht
sicher, dass es auch von gcc verwendet wird. Erneutes Kompilieren von gcc,
nach der Installation von gas, oder das symbolische Verlinken von cc, as und
ld auf die GNU-Tools ist vermutlich notwendig.

NetBSD-Info:
Stellen Sie sicher, dass Sie die Optionen USER_LDT, SYSVSHM, SYSVSEM und
SYSVMSG in Ihrem Kernel aktiviert haben.

Mac OS X Info:
Sie benötigen Xcode/Xcode-Kommandozeilentools oder Apple cctools.

Unterstützte Dateisysteme:
Wine sollte auf den meisten Dateisystemen laufen. Kompatibilitätsprobleme
wurden allerdings beim Dateizugriff über Samba gemeldet.
Weiterhin bietet NTFS nicht alle Dateisystemfunktionen, die von einigen
Programmen benötigt werden. Ein natives Unix-Dateisystem ist empfohlen.

Grundsätzliche Voraussetzungen:
Sie müssen die Entwicklungsdateien für X11 installiert haben
(Debian nennt diese xorg-dev, Red Hat libX11-devel).
Selbstverständlich benötigen Sie auch make (höchstwahrscheinlich GNU make).
Des Weiteren benötigen Sie flex (Version 2.5.33 oder höher) und bison.

Optionale Bibliotheken:
Der Configure-Aufruf zeigt am Ende optionale Bibliotheken an,
die von Wine benutzt werden können, aber auf Ihrem System nicht gefunden
wurden. Tipps zum Installieren fehlender Pakete finden Sie unter:
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine
Unter 64-Bit-Plattformen benötigen Sie auch die 32-Bit-Versionen dieser
Bibliotheken.

KOMPILIEREN

Um Wine zu kompilieren, führen Sie aus:

text
./configure
make

Damit werden das Programm "wine" und diverse unterstützende Bibliotheken und
Binärdateien erstellt. Das Programm "wine" lädt ausführbare Windows-Dateien
und führt diese aus.
Die Bibliothek "libwine" ("Winelib") kann benutzt werden, um Windows-Quelltexte
unter Unix zu kompilieren und zu verlinken.

Mit ./configure --help können Sie sich Konfigurations-Optionen für die
Kompilierung anzeigen lassen.

Weitere Informationen finden Sie unter https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

SETUP

Nachdem Wine korrekt erstellt wurde, können Sie make install aufrufen;
Dadurch werden Wine-Programme und Bibliotheken, die Man-Page und andere nötige
Dateien installiert.

Vergessen Sie nicht, zuerst frühere Wine-Installationen zu entfernen, die mit
der neuen in Konflikt stehen könnten. Versuchen Sie entweder dpkg -r wine,
rpm -e wine oder make uninstall vor der Installation auszuführen.

Nach der Installation können Sie das Konfigurationswerkzeug winecfg starten.
Hinweise dazu finden Sie im Support-Bereich auf https://www.winehq.org/

AUSFÜHREN VON PROGRAMMEN

Wenn Sie Wine aufrufen, können Sie den vollständigen Pfad zur ausführbaren
Datei angeben oder nur einen Dateinamen.

Beispiel: Um Notepad auszuführen:

text
wine notepad            (wobei der Suchpfad, wie in der Registrierung
wine notepad.exe         angegeben, benutzt wird)

wine c:\\windows\\notepad.exe         (mit Dateinamen-Syntax von DOS)

wine ~/.wine/drive_c/windows/notepad.exe            (mit Unix-Syntax)

wine notepad.exe liesmich.txt         (Programmaufruf mit Parametern)

Wine ist nicht perfekt, manche Programme könnten abstürzen.
In solchen Fällen bekommen Sie einen Log vom Absturz, den Sie beifügen sollten,
wenn Sie den Fehler melden.

WEITERFÜHRENDE INFORMATIONEN

Documentation README Es (`documentation/README-es.md`)

INTRODUCCIÓN

Wine es un programa que permite la ejecución de programas de Microsoft Windows
(incluyendo ejecutables de DOS, Windows 3.x y Win32) sobre Unix. Consiste en un
programa cargador que carga y ejecuta un binario de Microsoft Windows, y una
librería (llamada Winelib) que implementa las llamadas a la API de Windows
usando sus equivalentes Unix o X11. La librería puede también utilizarse para
portar código Win32 a ejecutables Unix nativos.

Wine es software libre, publicado bajo la licencia GNU LGPL; vea el fichero
LICENSE para los detalles.

INICIO RÁPIDO

Cuando compile desde el código fuente, se recomienda utilizar el Instalador de
Wine para compilar e instalar Wine. Desde el directorio base del código de Wine
(el cual contiene este fichero), ejecute:

text
./configure
make

Ejecute aplicaciones con wine programa. Para más información y resolución de
problemas, continúe leyendo este archivo, la página man de Wine, o más
específicamente, la numerosa información que puede encontrar en
https://www.winehq.org.

REQUISITOS

Para compilar y ejecutar Wine, deberá tener uno de los siguientes:

  • Linux versión 2.6.22 o superior
  • FreeBSD 12.4 o superior
  • Solaris x86 9 o superior
  • NetBSD-current
  • macOS 10.15 o superior

Ya que Wine requiere soporte de hilos de ejecución a nivel de núcleo para
ejecutarse, sólo se soportan los sistemas operativos ya mencionados.
Otros sistemas operativos que soporten hilos de ejecución a nivel de núcleo
podrían obtener soporte en el futuro.

Información sobre FreeBSD:
Visite https://wiki.freebsd.org/Wine para más información.

Información sobre Solaris:
Lo más probable es que necesite compilar con el conjunto de herramientas GNU
(gcc, gas, etc.). Advertencia: instalar gas no asegura que sea utilizado
por gcc. Un comentario ampliamente extendido es que es necesario recompilar
gcc tras la instalación de gas o enlazar simbólicamente cc, as y ld a las
herramientas gnu.

Información de NetBSD:
Asegúrese de que tiene las opciones USER_LDT, SYSVSHM, SYSVSEM, y SYSVMSG
activadas en el núcleo.

Información de Mac OS X:
Necesitará Xcode 2.4 o posterior para compilar correctamente en x86.

Sistemas de ficheros soportados:
Wine puede ejecutarse en la mayoría de los sistemas de ficheros. Sin embargo,
se han reportado unos cuantos problemas de compatibilidad usando archivos
accedidos a través de Samba. Además, NTFS no proporciona todas las
funcionalidades necesitadas por algunas aplicaciones. Se recomienda el uso de
un sistema de ficheros Unix.

Requisitos básicos:
Necesitará tener instalados los archivos include X11 para desarrollo
(llamados xorg-dev en Debian y libX11-devel en RedHat).
Además necesitará make (preferiblemente GNU make).
También necesitará flex versión 2.5.33 o posterior y bison.

Librerías de soporte adicionales:
Configure mostrará advertencias cuando las librerías opcionales no se
encuentren disponibles en su sistema.
Visite https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine
para recomendaciones acerca de que paquetes debe instalar. En
plataformas de 64-bit, si se está compilando Wine 32-bits (es la
compilación por defecto), debe estar seguro de tener instaladas las
librerías de desarrollo de 32-bits.

COMPILACIÓN

En el caso de que elija no utilizar wineinstall, ejecute los siguientes
comandos para construir Wine:

text
./configure
make

Esto construirá el programa "wine" y numerosas librerías/binarios de soporte.
El programa "wine" cargará y ejecutará ejecutables de Windows.
La librería "libwine" ("Winelib") puede utilizarse para compilar y enlazar
código fuente de Windows bajo Unix.

Para ver las opciones de compilación, haga: ./configure --help.

CONFIGURACIÓN

Una vez que Wine se ha compilado correctamente, puede hacer make install;
esto instalará el ejecutable y librerías de wine, el manual de Wine, y el
resto de ficheros necesarios.

Recuerde desinstalar antes cualquier instalación anterior de Wine que pueda
crear conflictos. Realice un dpkg -r wine o rpm -e wine o make uninstall
antes de instalar.

Una vez instalado, puede ejecutar la herramienta de configuración winecfg.
Visite la zona de Soporte en https://www.winehq.org/ para consejos sobre la
configuración.

EJECUTANDO PROGRAMAS

Cuando invoque Wine, puede especificar la ruta completa al ejecutable, o sólo
el nombre del fichero.

Por ejemplo:

text
wine notepad                   (usando la ruta de búsqueda indicada en el
wine notepad.exe                el registro para encontrar el archivo)

wine c:\\windows\\notepad.exe  (usando la sintaxis de DOS)

wine ~/.wine/drive_c/windows/notepad.exe  (usando la sintaxis de Unix)

wine notepad.exe readme.txt (ejecutando el programa con parámetros)

Nota: la ruta del fichero también se añadirá a la ruta cuando se proporcione un
nombre completo en la línea de comandos.

Wine no es perfecto, algunos programas pueden fallar. Si esto le ocurre usted
recibirá un log de error que debe adjuntar en caso de reportar un fallo.

OBTENIENDO MÁS INFORMACIÓN

Documentation README Fi (`documentation/README-fi.md`)

JOHDANTO

Wine on ohjelma, jonka avulla Windows-ohjelmia (mukaan luettuna DOS-,
Windows 3.x, Win32 ja Win64 -ohjelmat) voi ajaa Unix-järjestelmissä.
Wine koostuu ohjelmanlataajasta, joka lataa ja käynnistää Windowsin
ohjelmatiedostoja, sekä kirjastosta nimeltä Winelib, joka toteuttaa
Windowsin API-kutsuja niiden Unix- ja X11-vastineiden avulla. Kirjaston
avulla voidaan myös kääntää Windows-koodia natiiveiksi Unix-ohjelmiksi.

Wine on vapaa ohjelma, ja se on julkaistu GNU LGPL:n alaisena; lisätietoja
lisenssistä on englanniksi tiedostossa LICENSE.

PIKAOPAS

Aja Winen lähdekoodin juurihakemistossa seuraavat komennot:

text
./configure
make

Sitten joko asenna Wine:

text
make install

Tai aja se käännöshakemistosta:

text
./wine notepad

Ohjelmat ajetaan komennolla wine ohjelma. Lisätietoja sekä apua ongelmien
ratkaisemiseen on jäljempänä tässä tiedostossa, Winen man-sivuilla sekä
ennen kaikkea Internetissä osoitteessa https://www.winehq.org/.

JÄRJESTELMÄVAATIMUKSET

Winen kääntämiseen tarvitaan jokin seuraavista:

  • Linuxin versio 2.6.22 tai uudempi
  • FreeBSD 12.4 tai uudempi
  • Solaris x86 9 tai uudempi
  • NetBSD-current
  • macOS 10.15 tai uudempi

Wine vaatii kerneliltä tuen säikeille. Tämän takia toistaiseksi vain yllä
mainittuja käyttöjärjestelmiä tuetaan; tulevaisuudessa saatetaan lisätä tuki
muillekin käyttöjärjestelmille, joissa on tarvittava tuki säikeille.

Tietoa FreeBSD:lle:
Osoitteessa https://wiki.freebsd.org/Wine on lisätietoa.

Tietoa Solarikselle:
Wine täytyy luultavasti kääntää GNU-työkaluilla (gcc, gas jne.).
Varoitus: vaikka gas olisi asennettu, ei ole varmaa, että gcc käyttää sitä;
voi olla tarpeen joko kääntää gcc uudestaan tai luoda symboliset linkit
ohjelmista "cc", "as" ja "ld" vastaaviin GNU-työkaluihin.

Tietoa NetBSD:lle:
USER_LDT, SYSVSHM, SYSVSEM ja SYSVMSG täytyy aktivoida kernelistä.

Tietoa Mac OS X:lle:
Winen kääntämiseen tarvitaan Xcode Command Line Tools tai Apple cctools.

Tuetut tiedostojärjestelmät:
Wine toimii useimmilla tiedostojärjestelmillä, mutta Samban kanssa on
ilmoitettu ilmenevän ongelmia. Myöskään NTFS ei tue kaikkia ominaisuuksia,
joita jotkin ohjelmat vaativat. Natiivin Unix-tiedostojärjestelmän käyttö
on suotavaa.

Perusvaatimukset:
Koneella täytyy olla X11:n kehitystiedostot (Debianissa xorg-dev,
Red Hatissa libX11-devel).
Luonnollisesti myös make (yleensä GNU make) on tarpeen.
Lisäksi tarvitaan flex 2.5.33 tai uudempi sekä bison.

Valinnaisia tukikirjastoja:
configure-skripti näyttää varoituksia, kun valinnaisia kirjastoja puuttuu.
Osoitteessa https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine on tietoa, mitkä
paketit ovat hyödyksi. 64-bittisissä järjestelmissä täytyy varmistaa, että
kirjastoista on asennettu 32-bittiset versiot.

KÄÄNTÄMINEN

Winen voi kääntää seuraavilla komennoilla:

text
./configure
make

Tämä kääntää ohjelman "wine" sekä lukuisia tukikirjastoja ja -ohjelmia.
Ohjelma "wine" lataa ja käynnistää Windows-ohjelmia.
Kirjastoa "libwine" ("Winelib") voidaan käyttää Windows-lähdekoodin
kääntämiseen Unixissa.

Komento ./configure --help näyttää asetuksia ja valintoja, joita
käännösprosessiin voi lisätä.

Lisätietoja on osoitteessa https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

ASENNUS

Kun Wine on käännetty, komento make install asentaa Winen sekä sen man-sivut
ja joitakin muita hyödyllisiä tiedostoja.

Ennen asennusta pitää muistaa poistaa aiemmat Winen versiot. Poistamista
voi yrittää komennolla dpkg -r wine, rpm -e wine tai make uninstall.

Kun Wine on asennettu, voidaan ajaa asetusohjelma winecfg. Sivustolla
https://www.winehq.org/ kohdassa Support on englanninkielisiä lisäohjeita.

OHJELMIEN AJAMINEN

Winelle voi antaa joko ohjelmatiedoston koko polun tai pelkän nimen.

Esimerkiksi Notepad eli Muistio voitaisiin ajaa näin:

text
wine notepad               (ohjelma yritetään löytää Winen
wine notepad.exe            rekisterissä luetelluista paikoista)

wine c:\\windows\\notepad.exe  (kokonainen DOS-polku)

wine ~/.wine/drive_c/windows/notepad.exe  (kokonainen Unix-polku)

wine notepad.exe readme.txt  (ajetaan ohjelma parametrin kanssa)

Wine ei ole täydellinen, joten on mahdollista, että jotkin ohjelmat kaatuvat.
Siinä tapauksessa komentoriville tulostuu virheloki, joka on syytä liittää
mukaan, jos raportoi virheestä.

LISÄTIETOJA

Documentation README Fr (`documentation/README-fr.md`)

INTRODUCTION

Wine est un programme qui permet d'exécuter les logiciels écrits pour
Microsoft Windows (comprenant les exécutables DOS, Windows 3.x, Win32 et
Win64) sur un système Unix. Il est composé d'un chargeur qui charge et
exécute un binaire Microsoft Windows, ainsi que d'une bibliothèque (appelée
Winelib) qui implémente les appels de l'API de Windows à l'aide de leurs
équivalents Unix, X11 ou Mac. Cette bibliothèque peut également être
utilisée pour porter du code Windows vers un exécutable Unix natif.

Wine est un logiciel libre, distribué sous GNU LGPL ; lisez le fichier
LICENSE pour plus de détails.

DÉMARRAGE RAPIDE

Dans le dossier racine du code source de Wine (qui contient ce fichier),
lancez :

text
./configure
make

Pour exécuter un programme, tapez wine programme. Pour des informations
complémentaires et la résolutions de problèmes, lisez la suite de ce
fichier, les pages de manuel de Wine, et surtout les nombreuses
informations que vous trouverez sur https://www.winehq.org.

CONFIGURATION NÉCESSAIRE

Pour compiler et exécuter Wine, vous devez disposer d'un des systèmes
d'exploitation suivants :

  • Linux version 2.6.22 ou ultérieur
  • FreeBSD 12.4 ou ultérieur
  • Solaris x86 9 ou ultérieur
  • NetBSD-current
  • macOS 10.15 ou ultérieur

Étant donné que Wine nécessite une implémentation des « threads »
(processus légers) au niveau du noyau, seuls les systèmes d'exploitation
mentionnés ci-dessus sont supportés. D'autres systèmes d'exploitation
implémentant les threads noyau seront peut-être pris en charge dans le
futur.

Informations FreeBSD :
Wine ne fonctionnera généralement pas bien avec les versions FreeBSD
antérieures à 8.0. Voyez https://wiki.freebsd.org/Wine pour plus
d'informations.

Informations Solaris :
Il est plus que probable que vous deviez construire Wine avec la chaîne
d'outils GNU (gcc, gas, etc.). Attention : installer gas n'assure pas
qu'il sera utilisé par gcc. Recompiler gcc après l'installation de gas
ou créer un lien symbolique de cc, as et ld vers les outils GNU
correspondants semble nécessaire.

Informations NetBSD :
Assurez-vous que les options USER_LDT, SYSVSHM, SYSVSEM et SYSVMSG sont
activées dans votre noyau.

Informations Mac OS X :
Xcode 2.4 ou ultérieur est nécessaire pour compiler Wine sous x86.

Systèmes de fichiers pris en charge :
Wine devrait fonctionner sur la plupart des systèmes de fichiers.
Certains problèmes de compatibilité ont été rapportés lors de
l'utilisation de fichiers accédés via Samba. De plus, NTFS ne fournit pas
toutes les fonctionnalités de système de fichiers nécessaires pour
certains applications. L'utilisation d'un système de fichiers Unix natif
est recommandée.

Configuration de base requise :
Les fichiers d'en-tête de X11 (appelés xorg-dev sous Debian et
libX11-devel sous Red Hat) doivent être installés.
Bien entendu, vous aurez besoin du programme « make » (très probablement
GNU make).
flex 2.5.33 ou ultérieur, ainsi que bison, sont également requis.

Bibliothèques optionnelles :
« configure » affiche des messages quand des bibliothèques optionnelles
ne sont pas détectées sur votre système.
Consultez https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine
(en anglais) pour des indications sur les paquets logiciels que vous
devriez installer. Sur les plates-formes 64 bits, si vous compilez
Wine pour le mode 32 bits (mode par défaut), les versions 32 bits de
ces bibliothèques doivent être installées.

COMPILATION

Pour compiler Wine, lancez :

text
./configure
make

Cela va construire le programme « wine », ainsi que nombreux binaires et
bibliothèques de support.
Le programme « wine » charge et exécute les exécutables Windows.
La bibliothèque « libwine » (alias « Winelib ») peut être utilisée pour
compiler et lier du code source Windows sous Unix.

Pour voir les options de compilation, tapez ./configure --help.

Pour plus d'information consultez https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

INSTALLATION

Une fois Wine construit correctement, make install installe
l'exécutable wine, les bibliothèques associées, les pages de manuel de
Wine et quelques autres fichiers nécessaires.

N'oubliez pas de désinstaller toutes les installations précédentes :
essayez dpkg -r wine, rpm -e wine ou make uninstall avant
d'installer une nouvelle version.

Une fois l'installation terminée, vous pouvez lancer l'outil de
configuration winecfg. Consultez la section Support de
https://www.winehq.org/ pour obtenir des astuces de configuration.

EXÉCUTER DES PROGRAMMES

Au démarrage de Wine, vous pouvez spécifier le chemin entier vers
l'exécutable ou seulement le nom de fichier.

Par exemple pour exécuter le bloc-notes :

text
wine notepad               (en utilisant le chemin d'accès spécifié
wine notepad.exe            dans la base de registre pour localiser
                            le fichier)

wine c:\\windows\\notepad.exe
        (en utilisant la syntaxe de fichiers DOS)

wine ~/.wine/drive_c/windows/notepad.exe
        (en utilisant la syntaxe Unix)

wine notepad.exe lisezmoi.txt
        (en appelant le programme avec des paramètres)

Wine n'est pas parfait, et certains programmes peuvent donc planter. Si
cela se produit, vous obtiendrez un journal du crash qu'il est recommandé
d'attacher à un éventuel rapport de bogue.

SOURCES D'INFORMATIONS COMPLÉMENTAIRES

Documentation README Hu (`documentation/README-hu.md`)

BEVEZETÉS

A Wine egy program amivel lehetõség nyílik a Microsoft Windows
programok futtatására (beleértve a DOS, Windows 3.x és Win32
futtatható állományokat) Unix alatt. Tartalmaz egy program betöltõt,
ami betölt és futtat egy Microsoft Windows binárist, és egy
függvénykönyvtárat (nevén Winelib), ami implementálja a Windows
API hívásokat azok Unix, vagy X11 megfelelõinek használatával.
Ez a függvénykönyvtár használható a Win32 kód natív Unix futtatható
állománnyá portlásához.

A Wine egy szabad szoftver, a GNU LGPL alatt kiadva; nézze meg a
LICENSE fájlt a részletekért.

GYORS INDÍTÁS

Ha ön forrásból fordította, ajánlott a Wine telepítõ használata a
a Wine lefordításához és telepítéséhez. A Wine forráskód szülõ-
könyvtárából (ami tartalmazza ezt a fájlt), futtassa:

text
./configure
make

A programok futtatása wine program. A további információkhoz
és a probléma felvilágosításhoz olvassa el ennek a fájlnak a további részét,
a Wine man oldalát, és különösen gazdag információ található itt:
https://www.winehq.org.

KÖVETELMÉNYEK

A Wine-nak a fordításához és futtatásához önnek szüksége lesz a következõkbõl
egynek:

  • Linux 2.6.22-os, vagy feletti verzió
  • FreeBSD 12.4, vagy késõbbi
  • Solaris x86 9, vagy késõbbi
  • NetBSD-current
  • macOS 10.15, vagy késõbbi

Mivel a Wine-nak kükséges kernelszintû futási szál támogatás a futtatáshoz, csak
a fent említett operációs rendszerek támogatottak.
Más operációs rendszerek, amik támogatják a kernel futási szálakat, támogatva
lesznek a jövõben.

FreeBSD információ:
Több információ található a FreeBSD ports fában itt:
ftp://ftp.freebsd.org/pub/FreeBSD/ports/ports/emulators/wine/.

Solaris információ:
A Wine fordításához kell a GNU toolchain (gcc, gas, etc.).
Figyelem : A gas telepítése nemt biztosíték, hogy a gcc fogja is
használni. A gcc újrafordítása a gas telepítése után, vagy a cc
szimbolikus linkelése, és ld-zése a gnu tools-hoz szükséges.

NetBSD információ:
ellenõrizze, hogy a USER_LDT, SYSVSHM, SYSVSEM, és SYSVMSG opciók be vannak-e
kapcsolva a kernelben.

Támogatott fájlrendszerek:
A Wine fut a legtöbb fájlrendszeren. Habár a Wine nem fog elindulni, ha
umsdos-t használunk a /tmp könyvtárban. Néhány kompatibilitási gondot
is bejelentettek a Sambán keresztül elért fájlok esetében. Az NTFS-t
lehet használni biztonságban írásvédett hozzáféréssel, de az NTFS ellen
szól, hogy a Windows programoknak majdnem mindenhova írási jog kell.
NTFS fájlok esetén másoljuk át õket egy írható helyre.

Alap követelmények:
Önnek fel kell telepítenie az X11 fejlesztõi fájlokat
(xorg-dev néven van a Debianban és libX11-devel néven a Red Hat-ben).

Fordítási eszköz követelmények:
x86 rendszereken gcc >= 2.7.2 szükséges.
A 2.7.2.3-nál régebbi verziókban problémák lehetnek különféle fájlokkal,
amik optimalizációval lettek fordítva, gyakran a fejléc fájlok kezelésének
problémái miatt. A pgcc jelenelg nem mûködik s Wine-sl. A probléma oka
ismeretlen.
Természetesen kell a make is (leginkább a GNU make).
Kell még a flex 2.5 verzió, vagy késõbbi, és a bison.

Opciónális támogatási függvénykönyvtárak:
Ha szeretne CUPS nyomtató támogatást, telepítse fel a cups és a cups-devel
csomagot.
Telepítse fel a libxml2 csomagot, ha szeretné hogy mûködjön az msxml
implementáció.

FORDÍTÁS

Ha ön nem használja a wineinstall-t, futtassa a következõ parancsokat s
Wine fordításához:

text
./configure
make

Ez le fogja fordítani a "wine" programot és számos függvénykönyvtárat/binárist.
A "wine" program be fogja tölteni és futtatni fogja a Windows futtatható
állományokat.
A "libwine" függvénykönyvtár ("Winelib") használható a Windows forráskód Unix
alatt történõ fordításához és linkeléséhez.

A fordítási konfigurációs opciók megtekinétéséhez nézze használja a ./configure --help
parancsot.

TELEPÍTÉS

Ha a Wine egyszer helyesen lefordult, használhatja a make install
parancsot; ez telepíteni fogja a wine futtatható fájlt, a Wine man
oldalát, és néhány egyéb szükséges fájlt.

Elõször ne felejtse eltávolítani bármely elõzõ Wine telepítést.
Próbálja ki a dpkg -r wine, és az rpm -e wine, vagy a make uninstall
parancsot telepítés elõtt.

Látogassa meg a támogatási oldalt itt: https://www.winehq.org/ a konfigurációs
tippekhez.

PROGRAMOK FUTTATÁSA

Ha segítségül hívja a Wine-t, megadhatja a teljes útvonalát a futtatható
állománynak, vagy csak a fájlnevet.

Például:

text
wine notepad		   (a konfigfájlban megadott keresési útvonal
wine notepad.exe		    használatával keressük meg a fájlt)

wine c:\\windows\\notepad.exe  (a DOS fájlnév szintaxis használatával)

wine ~/.wine/drive_c/windows/notepad.exe  (a Unix-os fájlnév szintaxis használatával)

wine notepad.exe readme.txt          (program hívása paraméterekkel)

Felhívás: a fájl eléséi útja is hozzá lesz adva a path-hez, ha a teljes név
meg lett adva a parancssorban.

TÖBB INFORMÁCIÓ BESZERZÉSE

Documentation README It (`documentation/README-it.md`)

INTRODUZIONE

Wine è un programma che permette di eseguire programmi sviluppati per
Microsoft Windows (compresi eseguibili DOS, Windows 3.x, Win32, and
Win64) on Unix. Consiste di un caricatore di programmi che carica ed
esegue un binario Microsoft Windows, e di una libreria (chiamata Winelib)
che implementa le chiamate alle API Windows usando i loro equivalenti
Unix o X11. La libreria può essere usata anche per portare codice Windows
in eseguibili nativi Unix.

Wine è un software libero, rilasciato sotto la GNU LGPL; leggere il file
LICENSE per maggiori dettagli.

QUICK START

Compilando da sorgente, si raccomanda di usare l'Installer di Wine per
compilare ed installare Wine. Dalla cartella principale del sorgente di
Wine, eseguire:

text
./configure
make

Eseguire i programmi com wine programma. Per maggiori informazioni e
risoluzioni di problemi, leggere il resto di questo file, la pagina man
di Wine, ed in modo particolare la notevole quantità di informazioni che
si trova all'indirizzo https://www.winehq.org.

REQUISITI

Per compilare ed eseguire Wine, è necessario avere uno dei seguenti sistemi:

  • Linux versione 2.6.22 o successiva
  • FreeBSD 12.4 o successiva
  • Solaris x86 9 o successiva
  • NetBSD-current
  • macOS 10.15 o successiva

Poiché Wine richiede il supporto dei thread a livello kernel per funzionare,
solo i sistemi operativi sopra mentionati sono supportati. Altri sistemi
che forniscono kernel threads potrebbero essere supportati in futuro.

Informazioni per FreeBSD:
Leggere https://wiki.freebsd.org/Wine per maggiori informazioni.

Informazioni per Solaris:
Sarà molto probabilmente necessario compilare Wine con i tool GNU
(gcc, gas, etc). Attenzione: installare gas non assicura che
sia usato da gcc. Sembra che sia necessario ricompilare gcc dopo
l'installazione di gas o il symlink di cc, as e ld per i tool GNU.

Informazioni per NetBSD:
Assicurarsi che le opzioni USER_LDT, SYSVSHM, SYSVSEM, e SYSVMSG siano
abilitate nel kernel.

Informazioni per Mac OS X:
È richiesto Xcode 2.4 o superiore per compilare correttamente su x86.

File system supportati:
Wine dovrebbe funzionare sulla maggior parte dei file system. Qualche
problema di compatibilità è stato riportato usando file acceduti
tramite Samba. Inoltre, NTFS non fornisce tutte le funzionalità di
file system necessarie per alcune applicazioni. Si raccomanda di usare
un file system nativo di Unix.

Requisiti basilari:
Devono essere installati i file include di sviluppo di X11
(chiamato xorg-dev in Debian e libX11-devel in Red Hat).
Ovviamente necessario anche make (possibilmente GNU make).
È richiesto anche flex versione 2.5.33 o superiore e bison.

Librerie opzionali di supporto:
Configure notificherà a video quando le librerie opzionali non sono
trovate sul sistema. Leggere https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine
per suggerimenti sui pacchetti da installare.
Su piattaforme a 64-bit, per compilare Wine a 32-bit (predefinito),
assicurarsi di installare la versione a 32-bit di queste librerie.

COMPILAZIONE

Nel caso in cui si scegliesse di non utilizzare wineinstall, eseguire
i seguenti comandi per compilare Wine:

text
./configure
make

Questa sequenza compilerà il programma "wine" e numerose librerie e
binari di supporto.
Il programma "wine" caricherà ed eseguirà eseguibili Windows.
La libreria "libwine" ("Winelib") può essere usata per compilare e
linkare codice sorgente Windows sotto Unix.

Per vedere le opzioni di configurazione della compilazione, eseguire
./configure -help.

SETUP

Una volta che Wine è stato compilato correttamente, puoi eseguire
make install; questo installerà l'eseguibile wine, le librerie, la
pagina man di Wine, e altri file necessari.

Non dimenticarti di disinstallare qualsiasi precedente installazione
di Wine in conflitto. Prova sia dpkg -r wine o rpm -e wine o
make uninstall prima di installare.

Una volta installato, esegui lo strumento di configurazione winecfg.
Leggi l'area Support su https://www.winehq.org/ per suggerimenti sulla
configurazione.

ESEGUIRE PROGRAMMI

Quando si esegue Wine, si può specificare l'intero percorso
dell'eseguibile o solo il nome del file.

Per esempio, per eseguire Blocco Note:

text
wine notepad            (usando il percorso di ricerca come specificato
wine notepad.exe         nel registro per trovare il file)

wine c:\\windows\\notepad.exe      (usando la sintassi DOS)

wine ~/.wine/drive_c/windows/notepad.exe  (usando la sintassi Unix)

wine notepad.exe readme.txt     (chiamando il programma con dei parametri)

Wine non è perfetto, quindi alcuni programmi potrebbero andare in crash.
Se ciò accadesse, sarà creato un log del crash da aggiungere al rapporto
di segnalazione del problema.

PER OTTENERE PIÙ INFORMAZIONI

Documentation README Ja (`documentation/README-ja.md`)

はじめに

Wineは（DOS、Windows 3.x、Win32 や Win64 実行可能ファイルを含む）Microsoft
WindowsプログラムをUnix上で実行できるようにするプログラムです。
Microsoft Windowsバイナリを読み込んで実行するプログラムローダと、
UnixやX11同等物を使ってWindows APIの呼び出しを実装する（Winelibと呼ばれる）
ライブラリから成ります。ライブラリはWindowsのコードをネイティブな
Unix実行可能ファイルに移植するのにも使えます。

Wineはフリーソフトウェアで、GNU LGPLのもとでリリースされています。
詳細についてはLICENSEというファイルを参照してください。

クイックスタート

Wineソースのトップレベルディレクトリ（このファイル[訳注:README.jaではなく
READMEというファイル]を含むディレクトリ）から、以下を実行してください:

text
./configure
make

それから次のいずれか、Wineをインストールするか:

text
make install

または、Wineをビルドディレクトリから直接実行してください:

text
./wine notepad

wine programのようにプログラムを実行してください。更なる情報や
問題解決については、このファイルの残りの部分、Wineのmanページや、
特にhttps://www.winehq.orgで見つかる豊富な情報を読んでください。

要件

Wineをコンパイルし実行するには、以下のうち一つを持っていなければなりません:

  • Linux バージョン2.6.22以上
  • FreeBSD 12.4以降
  • Solaris x86 9以降
  • NetBSD-current
  • macOS 10.15以降

動作するためにWineにはカーネルレベルのスレッドのサポートが必要なので、
以上で触れたオペレーティングシステムだけがサポートされます。
カーネルスレッドをサポートする他のオペレーティングシステムは
将来サポートされるかもしれません。

FreeBSD情報:
詳細についてはhttps://wiki.freebsd.org/Wineを参照してください。

Solaris情報:
GNUツールチェーン（gcc、gasなど）でWineをビルドする必要がある可能性が
最も高いでしょう。警告 : gccがgasを使うことが、gasをインストールすることに
よって保証されるわけではありません。gasのインストール後にgccを
再コンパイルするか、cc、asやldをgnuツールにシンボリックリンクすることが
必要だと言われています。

NetBSD情報:
USER_LDT、SYSVSHM、SYSVSEMやSYSVMSGオプションがカーネルで有効になっている
かどうかを確認してください。

Mac OS X情報:
Xcode/Xcode Command Line ToolsまたはApple cctoolsが必要です。Wineを
コンパイルするための最小要件はclang 3.8とMacOSX10.10.sdkおよびmingw-w64
v8の組み合わせです。MacOSX10.14.sdkまたはそれ以降はwine64だけをビルドでき
ます。

サポートされたファイルシステム:
Wineはほとんどのファイルシステム上で動作するはずです。Sambaを通して
アクセスしたファイルを使っていくつかの互換性問題が報告されています。同様に、
NTFSはいくつかのアプリケーションで必要なファイルシステム機能すべてを提供し
ていません。ネイティブなUnixファイルシステムを使うことが推奨されます。

基本的な要件:
X11開発includeファイルをインストールする必要があります。
（Debianではxorg-devでRed HatではlibX11-develと呼ばれます。[訳注: 最近の
ディストリビューションでは別のパッケージで置き換えられています]）
もちろんmakeも必要です（大概はGNU make）。
flexバージョン2.5.33以降とbisonも必要です。

オプションのサポートライブラリ:
configureはオプションのライブラリがシステム上に見つからなかったときに通知を
表示します。インストールすべきパッケージについてのヒントについては
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wineを参照し
てください。64ビットプラットフォームでは、これらライブラリの32ビット
バージョンをインストールしたことをよく確認してください。

コンパイル

Wineをビルドするには以下のコマンドを実行してください:

text
./configure
make

これによって"wine"というプログラムと多数のサポートライブラリやバイナリが
ビルドされます。"wine"というプログラムはWindows実行可能ファイルを読み込み
実行します。"libwine" ("Winelib") というライブラリはUnixのもとでWindowsの
ソースコードをコンパイルしリンクするのに使えます。

コンパイル設定オプションを見るには、./configure --helpを行なってください。

更なる情報はhttps://gitlab.winehq.org/wine/wine/-/wikis/Building-Wineを参照してください。

設定

いったんWineが正しくビルドされると、make installを行なえます。
これによりwine実行可能ファイルとライブラリ、Wine manページやいくつかの必要な
ファイルがインストールされます。

まず、衝突するあらゆる前のWineインストールをアンインストールするのを
忘れないでください。インストール前にdpkg -r wineまたはrpm -e wine
またはmake uninstallを試してください。

いったんインストールされると、winecfg設定ツールを実行できます。
設定のヒントについてはhttps://www.winehq.org/におけるサポート領域を
参照してください。

プログラムの実行

Wineを起動するとき、実行可能ファイルのパス全体またはファイル名のみを
指定できます。

例えば、メモ帳を実行するには:

text
wine notepad            （レジストリで指定された、ファイルを検索
wine notepad.exe          するための検索パスを使う）

wine c:\\windows\\notepad.exe  （DOSファイル名の文法を使う）

wine ~/.wine/drive_c/windows/notepad.exe  （Unixファイル名の文法を使う）

wine notepad.exe readme.txt    （パラメータを付けてプログラムを呼ぶ）

Wineは完璧ではないので、いくつかのプログラムはクラッシュするかもしれません。
そのような場合はクラッシュログを得られるでしょう。クラッシュログはバグを報告
するときにレポートに添付するべきです。

更なる情報の取得

Documentation README Ko (`documentation/README-ko.md`)

소개

Wine은 Microsoft Windows 프로그램(DOS, Windows 3.x, Win32 및 Win64 실행
파일 포함)을 유닉스 상에서 실행할 수 있게 해 주는 프로그램입니다. Wine은
Microsoft Windows 바이너리를 로드하고 실행하는 프로그램 로더와 Unix, X11
또는 Mac API를 써서 Windows API를 구현한 라이브러리(Winelib)로 이루어져
있습니다. 이 라이브러리는 Windows 코드를 유닉스 실행 파일로 이식하는
용도로도 사용할 수 있습니다.

Wine은 자유 소프트웨어이며 GNU LGPL 하에 배포됩니다. 자세한 내용은
LICENSE 파일을 참조하십시오.

간편 설치 및 실행

Wine 소스의 최상위 디렉토리에서 다음 명령을 실행합니다.

text
./configure
make

그런 다음 Wine을 설치하거나

text
make install

또는 빌드 디렉터리에서 직접 Wine을 실행합니다.

text
./wine noetepad

프로그램을 실행할 때는 wine 프로그램명 처럼 합니다. 더 자세한 정보 및
문제 해결 방법은 이 파일의 나머지 부분과 Wine 맨페이지를 참조하십시오.
특히 https://www.winehq.org 사이트에 방대한 정보가 집약되어 있습니다.

빌드에 필요한 조건

Wine을 컴파일하고 실행하려면 다음 중 하나가 필요합니다.

  • 리눅스 2.6.22 또는 그 이후
  • FreeBSD 12.4 또는 그 이후
  • Solaris x86 9 또는 그 이후
  • NetBSD-current
  • macOS 10.15 또는 그 이후

Wine을 실행하려면 커널 차원의 스레드 지원이 필요하기 때문에 위에서 언급한
운영 체제만 지원합니다. 커널 스레드를 지원하는 다른 운영 체제는 향후
지원될 수 있습니다.

FreeBSD 정보:
더 자세한 정보는 https://wiki.freebsd.org/Wine 페이지를 참조하십시오.

Solaris 정보:
거의 대부분의 경우 Wine을 빌드하려면 GNU 툴체인(gcc, gas 등)을 사용해야
합니다. 경고: gas를 단순히 설치하기만 하면 gcc에서 사용되지 않을 수도
있습니다. gas를 설치한 다음 gcc를 재컴파일하거나 cc, as, ld 명령을 GNU
바이너리로 심볼릭 링크할 필요가 있다고 합니다.

NetBSD 정보:
USER_LDT, SYSVSHM, SYSVSEM, SYSVMSG 옵션이 커널에 포함되어야 합니다.

Mac OS X 정보:
Xcode/Xcode 명령 줄 도구 또는 Apple cctools가 필요합니다. Wine을
컴파일하려면 최소한 MacOSX10.10.sdk 포함 clang 3.8 및 mingw-w64 v8 이
필요합니다. MacOSX10.14.sdk 이상에서는 wine64만 빌드할 수 있습니다.

지원되는 파일 시스템:
Wine은 대부분의 파일 시스템에서 문제없이 실행됩니다. Samba를 이용해서
파일을 액세스하는 경우 몇 가지 호환성 문제가 보고되기도 했습니다. 또한,
NTFS는 일부 프로그램에서 필요로 하는 파일 시스템 기능 전부를 제공하지는
않습니다. 기본 Unix 파일 시스템을 사용하는 것이 좋습니다.

기본 요구 사항:
X11 개발용 헤더 파일이 설치되어 있어야 합니다 (데비안에서는 xorg-dev,
레드햇에서는 libX11-devel이란 패키지명으로 되어 있습니다).
당연히 make 프로그램도 필요합니다 (대부분 GNU make 사용).
flex 버전 2.5 이상과 bison이 필요합니다.

선택적 지원 라이브러리:
configure는 빌드 시스템에서 찾을 수 없는 선택적 라이브러리를 표시해
줍니다. https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine 에서 설치해야 하는
패키지에 대한 힌트를 얻을 수 있습니다. 64비트 플랫폼에서는 이러한
라이브러리의 32비트 버전을 설치해야 합니다.

컴파일하기

Wine을 빌드하려면 다음 명령을 실행합니다.

text
./configure
make

이렇게 하면 "wine" 프로그램과 다수의 라이브러리/바이너리가 빌드됩니다.
"wine" 프로그램은 Windows 실행 파일을 로드하고 실행하는 데 사용됩니다.
"libwine" 라이브러리("Winelib")는 Windows 소스 코드를 유닉스 상에서
컴파일하고 링크하는 용도로 사용할 수 있습니다.

컴파일 설정 옵션을 보려면 ./configure --help 명령을 사용합니다.

자세한 내용은 https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine 을 참조하십시오.

설정

Wine을 정상적으로 빌드한 다음에는 make install 명령으로 실행 파일과
라이브러리, Wine 맨페이지, 기타 필요한 파일을 시스템에 설치할 수 있습니다.

설치하기 전 이전 버전의 Wine을 제거해야 한다는 점을 잊지 마시기 바랍니다.
dpkg -r wine 또는 rpm -e wine 또는 make uninstall 등의 명령으로 이전
버전을 제거할 수 있습니다.

설치가 끝나면 winecfg 설정 도구를 실행할 수 있습니다. 설정 관련 힌트는
https://www.winehq.org/ 의 Support 페이지를 참조하십시오

프로그램 실행

Wine을 실행할 때 실행 파일의 전체 경로를 지정할 수도 있고 파일명만 지정할
수도 있습니다.

예를 들어 메모장을 실행하려면:

text
wine notepad                     (파일을 찾기 위해 레지스트리에
wine notepad.exe                  지정된 검색 경로를 이용)

wine c:\\windows\\notepad.exe                 (DOS 파일명 사용)

wine ~/.wine/drive_c/windows/notepad.exe   (유닉스 파일명 사용)

wine notepad.exe readme.txt      (프로그램에 매개변수를 넘겨줌)

Wine은 아직 완성 단계에 도달하지 못했기 때문에 프로그램이 제대로 실행되지
않을 수 있습니다. 프로그램이 죽었을 경우 버그 보고서에 첨부해야 하는 충돌
로그가 생성됩니다.

더 자세한 정보

Documentation README Nl (`documentation/README-nl.md`)

INTRODUCTIE

Wine is een programma wat het mogelijk maakt om Microsoft Windows
programma's (waaronder uitvoerbare DOS, Windows 3.x, Win32 en Win64
bestanden) op Unix uit te voeren. Het bestaat uit een programma-
lader die het Microsoft Windows binaire bestand laadt en uitvoert.
Een bibliotheek (Winelib genaamd) die de Windows API aanroepen laat
uitvoeren door overeenkomstige Unix, X11 of Mac varianten. Deze
bibliotheek kan ook worden gebruikt om Windows code om te zetten in
echte Unix uitvoerbare bestanden.

Wine is vrije software, uitgebracht onder de GNU LGPL. Zie het
LICENCE bestand voor meer informatie.

SNEL AAN DE SLAG

Voer in de hoofdmap van de Wine broncode (waar het README bestand staat),
het volgende uit:

text
./configure
make

Installeer daarna Wine met:

text
make install

Of voer Wine uit in de map waarin die gebouwd is:

text
./wine notepad

Programma's kunnen uitgevoerd worden met wine programma. Lees voor meer
informatie en het oplossingen van problemen de rest van dit bestand, de
man pagina's van Wine en vooral de overvloed aan informatie op
https://winehq.org .

BENODIGDHEDEN

Om Wine te kunnen compileren en uit te voeren, is één van het volgende
besturingssystemen nodig:

  • Linux versie 2.6.22 of nieuwer
  • FreeBSD 12.4 of nieuwer
  • Solaris x86 9 of nieuwer
  • NetBSD-current
  • macOS 10.15 of nieuwer

Omdat Wine threadondersteuning op kernelniveau vereist, worden alleen de
bovenstaande besturingssystemen ondersteund. Andere besturingssystemen
die threadondersteuning op kernelniveau hebben, kunnen mogelijk in de
toekomst ook ondersteund worden.

FreeBSD informatie:
Zie https://wiki.freebsd.org/Wine voor meer informatie.

Solaris informatie:
Hoogst waarschijnlijk moet Wine gebouwd worden met de GNU toolchain
(gcc, gas, enz.). Waarschuwing: het installeren van gas houdt niet
in dat het gebruikt wordt door gcc. Hercompileren van gcc nadat gas
is geïnstalleerd of symbolische verwijzingen maken voor cc, as en
ld naar de gnu-tools is waarschijnlijk noodzakelijk.

NetBSD informatie:
Zorg er voor dat de volgende opties aan staan in de kernel: USER_LDT,
SYSVSHM, SYSVSEM, en SYSVMSG.

Mac OS X informatie:
Xcode/Xcode Command Line Tools of Apple cctools zijn nodig.

Ondersteunde bestandssystemen:
Wine zou op de meeste bestandssystemen uitgevoerd moeten kunnen worden.
Er zijn enkele compatibiliteitsproblemen bekend met bestanden die via
Samba worden benaderd. Ook heeft NTFS niet alle bestandssysteemopties die
nodig zijn met sommige programma's. Een oorspronkelijk Unix
bestandssysteem wordt aangeraden.

Basis benodigdheden:
De X11-ontwikkel-bestanden moeten geïnstalleerd zijn. (Voor Debian is dat
pakket xorg-dev in RedHat is dit libX11-devel).
Natuurlijk is ook make nodig. (Hoogst waarschijnlijk GNU make.)
Ook zijn bison en flex versie 2.5.33 of nieuwer nodig.

Optionele bibliotheken:
Tijdens het uitvoeren van ./configure wordt er aangegeven of de optionele
bibliotheken zijn gevonden op het systeem. Bekijk
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine voor meer
informatie over welke pakketten er geïnstalleerd zouden moeten
worden. Op 64-bit systemen moeten ook de 32-bit versies van deze
pakketten geïnstalleerd worden.

COMPILEREN

Om Wine te bouwen, voer het volgende uit:

text
./configure
make

Hiermee wordt het programma "wine" en talrijke ondersteunende bibliotheken
en uitvoerbare bestanden gemaakt. Het programma "wine" laadt en voert de
uitvoerbare Windows bestanden uit.
De bibliotheek "libwine" ("Winelib") kan worden gebruikt om Windows
broncode te compileren en te linken in Unix.

Voor alle opties tijdens het compileren, voer ./configure --help uit.

Voor meer informatie bekijk: https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

SETUP

Wanneer Wine goed in elkaar is gezet, kan Wine geïnstalleerd worden met
make install. Deze opdracht installeert het uitvoerbare wine bestand,
de bibliotheken, de Wine man pagina's en alle andere benodigde bestanden.

Vergeet niet om eerst elke tegenstrijdige Wine installatie te verwijderen.
Dit kan voor de installatie met dpkg -r wine, rpm -e wine of met
make uninstall

Eenmaal geïnstalleerd, kan het configuratie programma winecfg worden
uitgevoerd. Bekijk de Support pagina op https://www.winehq.org/ voor
configuratiehints.

PROGRAMMA'S UITVOEREN

Bij het gebruiken van Wine kan het gehele pad naar het uitvoerbare bestand
worden gebruikt of alleen de bestandsnaam.

Voorbeeld: het Kladblok (Notepad) uitvoeren:

text
wine notepad           (gebruikt het zoek-pad, zoals in het register is
wine notepad.exe        opgegeven, om het bestand te vinden)

wine c:\\windows\\notepad.exe    (met een DOS bestandsnaam constructie)

wine ~/.wine/drive_c/windows/notepad.exe         (een Unix constructie)

wine notepad.exe readme.txt              (een programma met parameters)

Wine is niet perfect. Dus sommige programma's kunnen crashen. Als dat
gebeurd komt er een logboek van de crash. Deze kan bijgevoegd worden als de
fout wordt gerapporteerd.

MEER INFORMATIE

Documentation README No (`documentation/README-no.md`)

INTRODUKSJON

Wine er et program som gjør det mulig å kjøre Windows-programmer
(inkludert DOS, Windows 3.x, Win32 og Win64) i Unix. Det består av en
programstarter som starter og kjører en Windows-programfil, og et
bibliotek kalt «Winelib»; en uavhengig utgave av Windows' API som
bruker Unix- eller X11-funksjoner. Biblioteket kan også brukes til å putte
Windows-kode i vanlige Unix-programmer.

Wine er fri programvare, utgitt under vilkårene i GNU LGPL; se
filen «LICENSE» for detaljer.

KOM I GANG

Det anbefales å bruke Wines installasjonsprogram for å bygge og
installere Wine når det bygges fra kildekode. Kjør følgende i
rotkatalogen til Wine-kildekoden

text
./configure
make

Kjør programmer som wine program. Se resten av denne filen,
Wines man-side og https://www.winehq.org/ for mer informasjon og
problemløsing.

SYSTEMKRAV

Følgende kreves for å bygge og kjøre Wine:

  • Linux versjon 2.6.22 eller nyere
  • FreeBSD 12.4 eller nyere
  • Solaris x86 9 eller nyere
  • NetBSD-current
  • macOS 10.15 eller nyere

Wine krever støtte for tråder på kjernenivå, og derfor er det bare
operativsystemene ovenfor som støttes. Andre operativsystemer som
støtter kjernetråder støttes kanskje i framtiden.

Informasjon for FreeBSD:
Wine vil som regel ikke virke på FreeBSD-versjoner eldre enn 8.0.
Se https://wiki.freebsd.org/Wine for mer informasjon.

Informsjon for Solaris:
Wine må antakelig bygges med GNU-verktøyene (gcc, gas etc.).
Advarsel: selv om gas installeres er det ikke sikkert det brukes av
gcc. Det sies at gcc må bygges på nytt, eller at symbolske
koblinger for «cc», «as» og «ld» må legges til GNU-verktøyene.

Informasjon for NetBSD:
USER_LDT, SYSVSHM, SYSVSEM og SYSVMSG må være aktivert i kjernen.

Informasjon for Mac OS X:
Du må ha Xcode/Xcode Command Line Tools eller Apple cctools.

Støttede filsystemer:
Wine kan kjøre på de fleste filsystemer. Det har imidlertid vært
rapportert om problemer med filtilgang gjennom Samba. Vi anbefaler
ikke bruk av NTFS, siden dette ikke støtter funksjoner som noen
programmer trenger. Det anbefales å bruke et ekte Unix-filsystem.

Basiskrav:
Inkluderingsfilene for X11 må være installert (kalt «xorg-dev» i
Debian og «libX11-devel» i RedHat).
Du må selvfølgelig også ha «make», sannsynligvis «GNU make».
flex 2.5.33 eller nyere og bison er også nødvendig.

Valgfrie støttebiblioteker:
configure-skriptet viser meldinger når valgfrie biblioteker ikke
blir funnet. Se
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine for info
om hvilke pakker du bør installere. På 64 bit-systemer trenger du
32 bit-versjoner av disse bibliotekene hvis du skal bygge Wine som
et 32 bit-program (standard).

BYGGING

Kjør følgende kommandoer for å bygge Wine hvis du ikke bruker wineinstall:

text
./configure
make

Dette bygger programmet «wine» og diverse støttebiblioteker/programfiler.
Programfilen «wine» laster og kjører Windows-programmer.
Biblioteket «libwine» («Winelib») kan brukes til å bygge og koble
Windows-kildekode i Unix.

Kjør ./configure --help for å se valg for bygging.

INSTALLASJON

Når Wine er bygget kan du kjøre make install for å installere det;
dette installerer også man-siden og noen andre nødvendigheter.

Ikke glem å avinstallere tidligere Wine-versjoner først. Prøv enten
dpkg -r wine, rpm -e wine eller make uninstall før installsjonen.

Når Wine er installert kan du bruke oppsettsverktøyet winecfg.
Se støtteområdet på https://www.winehq.org/ for hint om oppsett.

KJØRING AV PROGRAMMER

Når du bruker Wine kan du oppgi hele stien til programfilen, eller bare
et filnavn.

Eksempel: for å kjøre Notisblokk:

text
wine notepad                   (ved å bruke søkestien oppgitt i
wine notepad.exe                Wine-registeret for å finne filen)

wine c:\\windows\\notepad.exe  (bruk av DOS-filbaner)

wine ~/.wine/drive_c/windows/notepad.exe  (bruk av Unix-filbaner)

wine notepad.exe readme.txt  (kjøre programmer med parametere)

Wine er ikke helt ferdig ennå, så det er mulig at noen programmer klikker.
Hvis dette skjer vil Wine lage en krasjlogg som du bør vedlegge til rapporten
når du rapporterer en feil.

MER INFORMASJON

Documentation README Pt (`documentation/README-pt.md`)

INTRODUÇÃO

Wine é um programa que permite correr programas Microsoft Windows
(incluindo DOS, Windows 3.x e Win32 executáveis) em Unix.
Consiste num carregador (loader), que carrega e executa um binário
Microsoft Windows, e uma livraria (chamada Winelib) que implementa
Windows API calls usando o Unix ou X11 equivalentes. A livraria também
pode ser usada para "porting" Win32 código para executáveis do nativo Unix .

Wine é software grátis,autorizado segundo a GNU LGPL; ver o ficheiro
LICENÇA para os detalhes.

ARRANQUE RÁPIDO

Sempre que se compila da source, é recomendado que se use o Wine
Installer para construir e instalar o Wine. Desde a primeira directoria
do Wine source (que contém este ficheiro),corre:

text
./configure
make

Corre os programas conforme as wine program. Para mais
informações e resoçução de problemas. Lê o resto deste ficheiro, a Wine
man page, e especialmente a abundância de informação encontrada em
https://www.winehq.org.

REQUERIMENTOS

Para compilar e correr o Wine, deves ter o seguinte:

  • Linux version 2.6.22 ou superior
  • FreeBSD 12.4 ou seguinte
  • Solaris x86 9 ou seguinte
  • NetBSD-current
  • macOS 10.15 ou seguinte

Como o Wine requer sequências kernel-level para poder correr, apenas
os sistemas operativos acima mencionados são suportados.
Outros sistemas operativos que suportam sequências kernel, talvez
venham a ser suportados no futuro.

FreeBSD info:
Mais informações encontra-se em:
ftp://ftp.freebsd.org/pub/FreeBSD/ports/ports/emulators/wine/

Solaris info:
Tu irás provavelmente ter que construir o Wine com as ferramentas GNU
(gcc, gas, etc.). Aviso: ao instalar gas não assegura que será usado
pelo gcc. Recompilar o gcc depois de instalar o gas ou symking cc, as e
ld para as ferramentas gnu é dito que é necessário.

NetBSD info:
Certifica-te que tens as opções USER_LDT, SYSVSHM, SYSVSEM, e SYSVMSG
ligadas ao teu kernel.

File systems info:
O Wine deverá correr na maioria dos file systems. Contudo, o Wine falha
no aranque se umsdos é usado para a directoria /tmp. Alguns problemas de
compatibilidades foram relatados estando a usar ficheiros acessados
através do Samba. Também, como o NTFS apenas pode ser usado com
segurança com acesso readonly por agora, nós não recomendamos o uso de
NTFS. Como os programas de Windows precisam de acesso write em quase tudo.
No caso de NTFS files, copia por cima para uma localização em que se
possa escrever.

Requisitos básicos:
Tu precisas de ter instalados os fucheiros de include do X11 development
(chamados xorg-dev em Debian e libX11-devel no RedHat).

Requisitos para as ferramentas de construção:
Em sistemas x86 o gcc >= 2.7.2 é requerido.
Versões anteriores à 2.7.2.3 poderão ter problemas quando certos
ficheiros são compilados com optimização, frequentemente devido a
problemas relacionados com as gestôes dos cabeçalhos dos ficheiros.
Actualmente o pgcc não trabalha com o Wine. A causa deste problema é
desconhecida.
Claro que também precisas fazer make (geralmente como o GNU make).
Tu também necessitas do flex versao 2.5 ou superior e o bison.
Se estiveres a usar RedHat ou Debian, instala os pacotes do flex e do bison.

Bibliotecas de suporte opcionais:
Se desejares suporte de impressão do CUPS, por favor instala os pacotes
cups e cups-devel.

COMPILAÇÃO

No caso de escolheres não usar wineinstall, corre os seguintes comandos
para contruir o Wine:

text
./configure
make

Isto irá contruir o programa "wine" e numerosos suportes livraris/binarios.
O programa "wine" irá carregar e correr executaveis do Windows.
A livraria "libwine" ("winelib") pode ser usada para compilar e ligar
Windows source code sob o Unix.

Para ver as opções de compilação da configuração, faz ./configure -help.

SETUP

Uma vez o Wine contruido correctamente, tu podes entao fazer o make install; isto irá instalar o wine executavel, o Wine man page, e alguns
outros ficheiros necessários.

Não esquecer de primeiro desinstalar qualquer previo conflito relativo a
instalação do Wine.
Tenta outro dpkg -r wine ou rpm -e wine ou make uninstall antes de
installar.

Ver https://www.winehq.org/support/ para informação sobre a
configuraçao.

CORRER PROGRAMAS

Quando e invoca o Wine, tens que especificar o caminho (patch) complecto
do executavel, ou apenas o nome do ficheiro.

Por exemplo:

text
wine notepad			(usando o searchpatch para lozalizar o ficheiro)
wine notepad.exe

wine c:\\windows\\notepad.exe	(usando um nome de ficheiro DOS)

wine ~/.wine/drive_c/windows/notepad.exe  (usando um nome de ficheiro Unix)

Nota: o caminho do ficheiro também irá ser adicionado ao caminho(patch)
quando um nome complecto é fornecido na linha de comando.

O Wine ainda não está complecto.então poderão vários programas
quebrar(crash). Providenciamos-te bem para que o winedbg esteja
correctamente e de acordo com a documentation/debugger.sgml, sera-te
dado um detector de erros (debugger) para que possas investigar e
corrigir os problemas.
Para mais informação como em fazer isto ou aquilo, por favor lê o
ficheiro documentation/debugging.sgml.

Tu deves fazer um backup de todos os teus ficheiros importantes em que
destes acesso ao Wine, ou usa uma especial cópia deles.tem havido casos
de certos users que têm feito relatos de ficheiros corronpidos. Não
corrar o Explorer, por exemplo, se não tiveres um backup próprio, que
por vezes renomeia e estraga algumas directorias. Nem todos os MS apps
como o e.g. Messenger são seguros, ao correrem o Explorer de alguma
maneira. Este caso particular de corrupeçao (!$!$!$!$.pfr) podem ao
menos parcialmente podem ser corrigidos usando
http://home.nexgo.de/andi.mohr/download/decorrupt_explorer

ARRANJAR MAIS INFORMAÇÃO

Documentation README Pt Br (`documentation/README-pt_br.md`)

INTRODUÇÃO

Wine é um programa que permite executar programas Microsoft Windows
(incluindo executáveis DOS, Windows 3.x, Win32 e Win64) no Unix.
Constituído de um programa carregador (loader) que carrega e executa
um binário Microsoft Windows, e uma biblioteca (chamada Winelib) que
implementa chamadas da API do Windows usando os equivalentes do Unix
ou do X11. A biblioteca também pode ser usada para portar código
Win32 em executáveis nativos Unix.

Wine é software livre, liberado segundo a GNU LGPL; veja o arquivo
LICENSE para detalhes.

INÍCIO RÁPIDO

Sempre que se compilam os fontes, é recomendado usar o Wine Installer
para construir e instalar o Wine. Estando no diretório de mais alto
nível do código fonte do Wine, execute:

text
./configure
make

Execute programas conforme wine programa. Para maiores informações
e resolução de problemas, leia o restante deste arquivo, a página
"man" do Wine (man wine), e especialmente a abundância de informação
encontrada em https://www.winehq.org.

REQUERIMENTOS

Para compilar e executar o Wine, você deve ter o seguinte:

  • Linux versão 2.6.22 ou posterior
  • FreeBSD 12.4 ou posterior
  • Solaris x86 9 ou posterior
  • NetBSD-atual
  • macOS 10.15 ou posterior

Como o Wine requer suporte a tarefas no nível de kernel para executar,
somente os sistemas operacionais acima mencionados são suportados.
Outros sistemas operacionais que suportarem tarefas do kernel poderão
ter suporte no futuro.

Informações para o FreeBSD:
Veja https://wiki.freebsd.org/Wine para mais informações.

Informações para o Solaris:
Você provavelmente necessitará construir o Wine com as ferramentas GNU
(gcc, gas, etc.). Aviso: instalar gas NÃO assegura que será usado pelo
gcc. Recompilar o gcc depois de instalar o gas ou criar uma ligação ao
cc, as e ld para as ferramentas gnu é dito ser necessário.

Informações para o NetBSD:
Certifique-se de ter as opções USER_LDT, SYSVSHM, SYSVSEM, e SYSVMSG
ligadas no kernel.

Informações para Mac OS X:
Será necessário o Xcode 2.4 ou superior para compilar corretamente no x86.
O driver gráfico Mac requer OS X 10.6 ou superior e não será usado no 10.5.

Sistemas de arquivo suportados:
O Wine deve rodar na maioria dos sistemas de arquivos. Alguns problemas de
compatibilidade foram reportados quando usado via Samba. Além disso, o NTFS
não provê todas as funcionalidades necessárias para alguns aplicativos.
Usar uma partição nativa Unix é recomendado.

Requisitos básicos:
Você necessita ter instalados os arquivos de inclusão para desenvolvimento
do X11 (chamados de xorg-dev no Debian e libX11-devel no RedHat).
Obviamente você também irá precisar do make (comumente o GNU make).
Também será necessário o flex versão 2.5.33 ou superior e o bison.

Bibliotecas de suporte opcionais:
O script configure irá mostrar diversas mensagens quando bibliotecas
opcionais não forem encontradas no seu sistema.
Veja https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine para
dicas sobre pacotes que você pode instalar.
Em plataformas de 64 bits, se compilar Wine como 32 bits (padrão), você
precisa assegurar que as versões 32 bits das bibliotecas estão instaladas.

COMPILAÇÃO

No caso de escolher não usar o wineinstall, execute os comandos a seguir
para construir o Wine:

text
./configure
make

Isto construirá o programa "wine" e vários binários/bibliotecas de suporte.
O programa "wine" carregará e executará executáveis do Windows.
A biblioteca "libwine" ("Winelib") pode ser usada para compilar e ligar
código-fonte do Windows sob o Unix.

Para ver as opções de compilação da configuração, rode ./configure --help.

CONFIGURAÇÃO

Uma vez que o Wine esteja construído corretamente, você pode executar
make install; assim irá instalar o executável do wine, as páginas
"man" do Wine, e outros arquivos necessários.

Não esqueça de desinstalar primeiramente qualquer instalação prévia do
Wine que possa ser conflitante. Tente tanto dpkg -r wine, rpm -e wine
ou make uninstall antes de instalar.

Depois de instalado, pode-se executar o programa de configuração winecfg.
Veja a área de suporte em https://www.winehq.org/ para dicas de configuração.

EXECUTANDO PROGRAMAS

Ao invocar o Wine, você pode especificar o caminho completo do executável,
ou somente um nome de arquivo.

Por exemplo, para executar o bloco de notas:

text
wine notepad                    (usando o caminho de pesquisa como
wine notepad.exe                 especificado no registro para
                                 encontrar o arquivo)

wine c:\\windows\\notepad.exe   (usando um nome de arquivo DOS)

wine ~/.wine/drive_c/windows/notepad.exe   (usando um nome de arquivo Unix)

wine notepad.exe leiame.txt     (chamando o programa com parâmetros)

O Wine não é perfeito, então alguns programas podem travar. Se isso
acontecer você verá um registro do travamento (crash log) que você
poderá anexar ao bug que for criar.

OBTENDO MAIS INFORMAÇÃO

Documentation README Ru (`documentation/README-ru.md`)

ВВЕДЕНИЕ

Wine - это программа, которая позволяет запускать программы Microsoft
Windows (включая исполняемые файлы формата DOS, Windows 3.x, Win32 и
Win64) на Unix. Она состоит из загрузчика, загружающего и выполняющего
программы Microsoft Windows, и библиотеки (Winelib), которая реализует
вызовы Windows API, используя их Unix- или X11-эквиваленты. Библиотека
также может быть использована для портирования кода Win32 в среду Unix.

Wine - свободное программное обеспечение, опубликованное по лицензии
GNU LGPL, файл LICENSE содержит информацию по лицензии.

БЫСТРЫЙ СТАРТ

В каталоге, содержащем исходный код Wine, выполните:

text
./configure
make

Запустите программу с помощью команды wine имя_программы. Источники
дополнительной информации перечислены в конце этого файла. Ознакомьтесь с
руководством по Wine, а также с сайтом https://www.winehq.org.

ТРЕБОВАНИЯ

Компиляция и запуск Wine поддерживается в следующих операционных системах:

  • Linux версии 2.6.22 или более новой
  • FreeBSD 12.4 или более новой
  • Solaris x86 9 или более новой
  • NetBSD-текущей версии
  • macOS 10.15 или более новой

Так как Wine требует для запуска поддержку потоков на уровне ядра,
поддерживаются только операционные системы, перечисленные выше. Другие
операционные системы с поддержкой многопоточности на уровне ядра
возможно будут поддерживаться Wine в будущем.

FreeBSD:
Wine не будет работать как следует на версиях ниже, чем FreeBSD 8.0.
Посетите https://wiki.freebsd.org/Wine для дополнительной информации.

Solaris:
Лучше всего компоновать Wine инструментами GNU
(gcc, gas, и т.д.). Внимание: установка gas НЕ гарантирует
что gcc будет его использовать. Необходимо перекомпилировать gcc после
установки gas или создать ссылку на cc, как и на ld в инструментах gnu.

NetBSD:
Убедитесь что, параметры USER_LDT, SYSVSHM, SYSVSEM и SYSVMSG
включены в вашем ядре.

Mac OS X:
Вам потребуется Xcode/Xcode Command Line Tools или Apple cctools.

Поддерживаемые файловые системы:
Wine должен работать на большинстве файловых систем. При использовании файлов
через Samba возможны некоторые проблемы с совместимостью. NTFS не обладает
необходимой функциональностью для запуска некоторых приложений.
Рекомендуется использовать родные файловые системы Unix.

Базовые требования:
У вас должны быть установлены заголовочные файлы X11
(xorg-dev в Debian и libX11-devel в Red Hat).
Разумеется, вам необходим «make» (лучше всего использовать GNU make).
Вам также понадобятся flex версии 2.5.33 или более новой и bison.

Дополнительные библиотеки:
Конфигурационный скрипт выведет список дополнительных библиотек, которые не были
найдены в вашей системе. Ознакомьтесь с перечнем необходимых пакетов по адресу
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine. При работе на 64-битных платформах
убедитесь, что у вас установлены 32-битные версии этих библиотек.

КОМПИЛЯЦИЯ

Для компиляции, выполните:

text
./configure
make

В результате вы получите программу «wine», библиотеки и бинарные файлы,
необходимые для работы Wine.
Программа «wine» нужна для загрузки и выполнения программ Windows.
Библиотека «libwine» («Winelib») может быть использована для компилирования и
компоновки исходного кода Windows под Unix.

Для вывода конфигурационных настроек введите ./configure --help.

За дополнительной информацией обратитесь к https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

УСТАНОВКА

Если компоновка Wine завершилась успешно, выполните make install. Это
установит исполняемые файлы wine, руководство Wine и некоторые
необходимые файлы.

Сначала не забудьте удалить любые конфликтующие версии Wine установленные ранее.
Попробуйте dpkg -r wine, rpm -e wine или make uninstall до установки.

После установки запустите конфигурационную программу winecfg. Посетите
Службу поддержки на https://www.winehq.org/, если возникнут вопросы по конфигурации.

ЗАПУСК ПРОГРАММ

Вы можете указывать путь до файла или только имя файла.

Например: запуск Блокнота:

text
wine notepad		   (используя пути, сохранённые
wine notepad.exe	    в реестре, для нахождения файла)

wine c:\\windows\\notepad.exe  (используя синтаксис DOS)

wine ~/.wine/drive_c/windows/notepad.exe  (используя синтаксис Unix)

wine notepad.exe readme.txt		   (вызов программы с параметрами)

Wine не идеален, поэтом некоторые программы могут завершаться с ошибкой.
Полученный в результате ошибке текстовый лог необходимо приложить к отчету
об ошибке.

ПОЛУЧЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ

  • WWW: Много информации о Wine доступно в WineHQ на
    https://www.winehq.org/: различные руководства Wine, база данных приложений,
    база данных ошибок. Вероятно лучше всего начать с этого сайта.

  • FAQ: Wine FAQ расположен на https://gitlab.winehq.org/wine/wine/-/wikis/FAQ

  • Wiki: Wine Wiki расположен на https://gitlab.winehq.org/wine/wine/-/wikis/

  • Gitlab: https://gitlab.winehq.org

  • Рассылки:
    Имеется несколько рассылок для пользователей и разработчиков
    Wine, обратитесь по адресу
    https://gitlab.winehq.org/wine/wine/-/wikis/Forums за
    дополнительной информацией.

  • Ошибки: Сообщайте об ошибках в Wine Bugzilla по адресу https://bugs.winehq.org
    Прежде чем отправлять сообщение об ошибке проверьте, может эта ошибка
    уже известна или исправлена в последней версии Wine.

  • IRC: Онлайн помощь доступна на канале #WineHQ на irc.libera.chat.

Documentation README Sv (`documentation/README-sv.md`)

INLEDNING

Wine är ett program som gör det möjligt att köra Windows-program
(inkluderat DOS, Windows 3.x, Win32 och Win64) i Unix. Det består av en
programstartare som startar och kör Windows-programfiler, samt ett
bibliotek (kallat Winelib) som implementerar Windows API-anrop med hjälp
av motsvarande Unix-, X11- eller Mac-anrop. Biblioteket kan också användas
till att porta Windows-kod till vanliga Unix-program.

Wine är fri programvara, utgett under villkoren i GNU LGPL; se
filen LICENSE för detaljer.

KOM IGÅNG

Kör följande kommandon i rotkatalogen för Wines källkod:

text
./configure
make

Efteråt antingen installera Wine:

text
make install

Eller kör Wine direkt från dess rotkatalog:

text
./wine notepad

Kör program med wine program. Se resten av denna fil,
Wines man-sidor samt sist men inte minst https://www.winehq.org/ för mer
information och tips om hur problem kan lösas.

SYSTEMKRAV

För att kompilera och köra Wine krävs ett av följande:

  • Linux version 2.6.22 eller senare
  • FreeBSD 12.4 eller senare
  • Solaris x86 9 eller senare
  • NetBSD-current
  • macOS 10.15 eller senare

Wine kräver stöd för trådar på kernelnivå, och därför är det bara
operativsystemen ovan som stöds. Andra operativsystem som
stöder kerneltrådar kommer eventuellt att stödjas i framtiden.

Information för FreeBSD:
Se https://wiki.freebsd.org/Wine för mer information.

Information för Solaris:
Wine måste antagligen byggas med GNU toolchain (gcc, gas etc.).
Varning: även om gas installeras så är det inte säkert att det används av
gcc. Det sägs att det är nödvändigt att antingen bygga gcc på nytt, eller
skapa symboliska länkar från "cc", "as" och "ld" till GNU toolchain.

Information för NetBSD:
USER_LDT, SYSVSHM, SYSVSEM och SYSVMSG måste vara aktiverade i kerneln.

Information för Mac OS X:
Du behöver Xcode 2.4 eller senare för att korrekt kunna bygga Wine på x86.
Mac-drivrutinen kräver OS X 10.6 eller senare och kommer inte att byggas på 10.5.

Stödda filsystem:
Wine kan köra på de flesta filsystem, men det har rapporterats problem vad
gäller kompatibilitet då samba används för att ansluta till filer. NTFS
tillhandahåller inte heller alla filsystemsfunktioner som behövs av alla
program. Det rekommenderas att använda ett riktigt Unix-filsystem.

Grundläggande krav:
Utvecklingsfilerna för X11 måste vara installerade (de kallas xorg-dev i
Debian och libX11-devel i Red Hat).
Du måste givetvis också ha make (mest troligt GNU make).
Det är också nödvändigt att ha flex 2.5.33 eller senare samt bison.

Valfria stödbibliotek:
configure-skriptet visar varningar när valfria bibliotek inte hittats.
Se https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine för
information om vilka paket du bör installera. På 64-bitars system
måste du säkerställa att du installerar 32-bitars versionerna av
dessa bibliotek.

KOMPILERING

Kör följande kommandon för att bygga Wine:

text
./configure
make

Detta bygger programmet "wine" och diverse stödbibliotek/programfiler.
Programfilen "wine" laddar och kör Windows-program.
Biblioteket "libwine" ("Winelib") kan användas till att bygga och länka
Windows-källkod i Unix.

Kör ./configure --help för att se inställningar och val vid kompilering.

För mer information se https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine

INSTALLATION

När Wine är byggt kan du köra make install för att installera det;
detta installerar också man-sidorna och några fler nödvändiga filer.

Glöm inte att först avinstallera gamla Wine-versioner. Pröva antingen
dpkg -r wine, rpm -e wine eller make uninstall före installationen.

När Wine är installerat kan du använda inställningsprogrammet winecfg.
Se hjälpavdelningen på https://www.winehq.org/ för tips om inställningar.

KÖRNING AV PROGRAM

När du använder Wine kan du uppge hela sökvägen till programfilen, eller
enbart ett filnamn.

Exempel: för att köra Notepad:

text
wine notepad               (använder sökvägen angiven i Wines
wine notepad.exe            konfigurationsfil för att finna filen)

wine c:\\windows\\notepad.exe  (användning av DOS-filnamnssyntax)

wine ~/.wine/drive_c/windows/notepad.exe  (användning av Unix-filvägar)

wine notepad.exe readme.txt  (köra program med parametrar)

Wine är inte perfekt, så det är möjligt att vissa program kraschar.
I så fall får du en kraschlogg som du bör bifoga till din rapport då du
rapporterar ett fel.

MER INFORMATION

Documentation README Tr (`documentation/README-tr.md`)

GİRİŞ

Wine Microsoft Windows uygulamalarını (DOS, Windows 3.x ve Win32
uygulamaları dahil) Unix uyumlu sistemler üzerinde çalıştırmanıza izin
veren bir programdır. Microsoft Windows çalıştırılabilir dosyalarını
yükleyip çalıştıran bir program yükleyici ve Windows API çağrılarını Unix
ve X11 eşdeğer çağrılarını kullanarak gerçekleyen Winelib isimli bir
kitaplıktan oluşur. Kitaplık ayrıca Win32 kodlarını doğal Unix
çalıştırılabilir dosyalarına çevirmek için kullanılabilir.

Wine, GNU LGPL altında dağıtılan özgür bir yazılımdır; ayrıntılar için
LICENSE dosyasına bakabilirsiniz.

HIZLI BAŞLANGIÇ

Eğer kaynaktan derlemek istiyorsanız, Wine'yi derlemek ve kurmak için Wine
Kur'u kullanmanız önerilir. Wine kaynak kodu içerisinde en üst dizine
(README dosyasını içerir) geçiniz ve şu komutu veriniz:

text
./configure
make

Programları wine program şeklinde çalıştırabilirsiniz.
Daha ayrıntılı bilgi ve sorun çözümü için, bu dosyanın geri kalanını,
Wine kullanım kılavuzunu ve özellikle https://www.winehq.org sitesindeki
zengin bilgi arşivini tarayabilirsiniz.

GEREKSİNİMLER

Wine'ı derlemek ve çalıştırmak için, aşağıdakilerden en az birine sahip
olmanız gerekir:

  • Linux 2.6.22 veya sonrası
  • FreeBSD 12.4 veya sonrası
  • Solaris x86 9 veya sonrası
  • NetBSD-current
  • macOS 10.15 veya sonrası

Wine çalışmak için çekirdek düzeyinde iş parçacığı desteğine ihtiyaç
duyduğundan sadece yukarıda söz edilen işletim sistemleri
desteklenmektedir.
Çekirdek düzeyinde iş parçacıklarını destekleyen diğer işletim sistemleri
de gelecekte desteklenebilir.

FreeBSD hakkında bilgi:
Ayrıntılı bilgi için https://wiki.freebsd.org/Wine adresini ziyaret
ediniz.

Solaris hakkında bilgi:
Wine'ı derlemek için muhtemelen GNU araçlarına (gcc, gas, vb.) ihtiyaç
duyacaksınız. Uyarı: gas kurmuş olmak onun gcc tarafından kullanılacağını
temin etmez. gas kurduktan sonra yeniden gcc derlemeniz veya cc, as ve ld
sembolik bağlantılarını gnu araçlarına ayarlamanız gerekmektedir.

NetBSD hakkında bilgi:
USER_LDT, SYSVSHM, SYSVSEM ve SYSVMSG seçeneklerinin çekirdeğinizde etkin
olduğundan emin olunuz.

macOS hakkında bilgi:
x86 üzerinde düzgün bir derleme yapabilmeniz için Xcode 2.4 veya daha yeni
bir sürüm gereklidir.
Mac sürücüsü için 10.6 veya daha üzeri gereklidir, sürücü 10.5'te derlenmez.

Desteklenen dosya sistemleri:
Wine birçok dosya sisteminde çalışabilir. Bununla beraber, Samba üzerinden
yapılan dosya erişimlerinde de birkaç uyumluluk sorunu bildirilmiştir.
Ayrıca, NTFS bazı uygulamalar için gereken bütün dosya sistemi özelliklerini
sağlamamaktadır. Unix için geliştirilen dosya sistemlerini kullanmanız önerilir.

Temel gereksinimler:
X11 geliştirme dosyalarının kurulu olması gereklidir.
(Debian'da xorg-dev, Red Hat'da libX11-devel adlı paketler).
make komutuna kesinlikle ihtiyacınız vardır. (çoğunlukla GNU make)
Ayrıca, flex 2.5.33 ve bison araçları da gereklidir.

Seçeneğe bağlı destek kitaplıkları:
Yapılandırılırken, eğer seçeneğe bağlı paketler bulunamadıysa, bildirim
alacaksınız. Yüklemeniz gereken paketler hakkında ipuçları için,
https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine adresini ziyaret ediniz.
64 bit üzerinde, eğer Wine'yi 32 bit (varsayılan) olarak derleyecekseniz,
bazı kitaplıklarin 32 bit sürümlerinin yüklü olduğundan emin olunuz.

DERLEME

Eğer wineinstall kullanmamayı seçtiyseniz, Wine'yi derlemek için aşağıdaki
komutları çalıştırınız:

text
./configure
make

Bu, "wine" programını ve destek kitaplıklarını/ikili dosyalarını
derleyecektir. "wine" programı Windows uygulamalarını yükleyecek ve
çalıştıracaktır. "libwine" ("Winelib") kitaplığı Windows programlarının
kaynak kodunu Unix altında derlemek ve bağlamak için kullanılabilir.

Derleme yapılandırma seçeneklerini görmek için ./configure --help komutunu giriniz.

KURULUM

Wine düzgün bir şekilde derlendiğinde, make install komutunu
verebilirsiniz; bu komut Wine çalıştırılabilir dosyalarını, kullanım
kılavuzunu ve gerekli birkaç dosyayı kuracaktır.

Önce, çakışan eski bir Wine kurulumunu kaldırmayı unutmayınız. Kurmadan
önce dpkg -r wine veya rpm -e wine veya pisi rm wine ya da make uninstall komutlarından birini deneyiniz.

Yüklemeden sonra, winecfg yapılandıma aracını
çalıştırabilirsiniz. Yapılandırma ipuçları için https://www.winehq.org/
adresinde Destek bölümüne bakınız.

UYGULAMALARIN ÇALIŞTIRILMASI

Wine'yi çağırırken çalışabilir dosyanın tam yolunu verebilir veya sadece
bir dosya adı belirtebilirsiniz.

Örneğin: Not Defteri'ni çalıştırmak için:

text
wine notepad		   (dosyaları konumlandırmak için config
wine notepad.exe	    dosyasındaki Path arama yolunu kullanarak)

wine c:\\windows\\notepad.exe  (DOS dosya adı sözdizimi ile)

wine ~/.wine/drive_c/windows/notepad.exe (Unix dosya adı sözdizimi ile)

wine notepad.exe readme.txt
			   (programı parametre vererek çağırma)

Wine tamamen bitmiş değildir; bu nedenle bazı programlar çökebilir. Bir
sorun oluştuğunda, bir çökme günlük dosyası alacaksınız, bu dosyayı hata
bildirirken eklemelisiniz.

DAHA FAZLA BİLGİYE ERİŞİM

Documentation README Uk (`documentation/README-uk.md`)

ВСТУП

Wine - це програма, яка дозволяє запускати програми Microsoft
Windows (включаючи DOS, Windows 3.x, Win32 та Win64) на Unix. Вона
складається з програми завантаження, яка завантажує та виконує програми
Microsoft Windows, і бібліотеки (Winelib), яка реалізує виклики
Windows API, використовуючи їх Unix- або X11-еквіваленти. Бібліотека
також може бути використана для портування коду Win32 в середовище Unix.

Wine - вільне програмне забезпечення, опубліковане за ліцензією
GNU LGPL; дивіться файл LICENSE за детальною інформацією.

ШВИДКИЙ СТАРТ

Кожен раз, коли ви компілюєте вихідний код, рекомендується використовувати
Wine Installer для компонування і встановлення Wine. У каталозі, що містить
вихідний код Wine (у ній знаходиться цей файл), введіть:

text
./configure
make

Запустіть програму як wine program. Додаткові джерела інформації
перераховані в кінці цього файлу. Ознайомтеся з посібником з Wine,
а також з сайтом https://www.winehq.org.

ВИМОГИ

Компіляція і запуск Wine підтримується в наступних операційних системах:

  • Linux версії 2.6.22 чи новіший
  • FreeBSD 12.4 чи новіший
  • Solaris x86 9 чи новіший
  • NetBSD-поточна версія
  • macOS 10.15 чи новіший

Оскільки Wine вимагає для запуску підтримку потоків на рівні ядра, підтримуються
тільки операційні системи, перераховані вище. Інші операційні системи,
з підтримкою багатопоковості ядром, можуть підтримуватися Wine в майбутньому.

FreeBSD:
Wine не буде працювати як слід на версіях нижче, ніж FreeBSD 6.3
чи 7.0. Для FreeBSD 6.3 є патч, що дозволяє Wine запускатися.
Відвідайте https://wiki.freebsd.org/Wine для додаткової інформації.

Solaris:
Найкраще збирати Wine інструментами GNU (gcc, gas, тощо). Увага:
встановлення gas НЕ гарантує що gcc буде його використовувати.
Необхідно перекомпілювати gcc після установки gas або створити
посилання на cc, як і на ld в інструментах gnu.

NetBSD:
Переконайтеся, що параметри USER_LDT, SYSVSHM, SYSVSEM і SYSVMSG
у вашому ядрі включені.

Mac OS X:
Вам потрібен Xcode 2.4 або більш новий для компіляції x86.

Підтримувані файлові системи:
Wine повинен працювати на більшості файлових систем. При використанні
файлів через Samba можливі деякі проблеми з сумісністю. NTFS не має
необхідної функціональності, потрібної для роботи деяких додатків.
Рекомендується використовувати файлові системи Linux, такі як ext3.

Базові вимоги:
У вас повинні бути встановлені файли заголовків X11
(xorg-dev в Debian та libX11-devel в Red Hat).
Звісно, вам потрібен make (краще всього використовувати GNU make).
Вам також знадобляться flex (версії 2.5.33 або новіший) та bison.

Додаткові бібліотеки підтримки:
Конфігураційний скрипт виведе список додаткових бібліотек, які не були
знайдені у вашій системі. Ознайомтеся з переліком потрібних пакетів за
адресою https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine.
На 64-бітних платформах ви повинні переконатися, що у вас встановлені
32-бітні версії цих бібліотек.

ЗБИРАННЯ

Якщо ви не хочете використовувати wineinstall, введіть наступні команди
для збирання Wine:

text
./configure
make

Це збере програму "wine" та інші необхідні бібліотеки та бінарні файли.
Програма "wine" буде завантажувати, і виконувати програми Windows.
Бібліотека "libwine" ("Winelib") може бути використана для компілювання
й компонування вихідного коду Windows під Unix.

Для виведення конфігураційних налаштувань виконайте ./configure --help.

ВСТАНОВЛЕННЯ

Після того як Wine буде успішно зібрано, виконайте make install; це
встановить виконувані файли Wine та бібліотеки, керівництво Wine та
інші необхідні файли.

Спочатку не забудьте видалити будь-які конфліктуючі раніше встановлені
версії Wine. Спробуйте dpkg -r wine або rpm -e wine чи make uninstall
перед встановленням.

Після встановлення запустіть конфігураційну програму winecfg. Відвідайте Службу
підтримки на https://www.winehq.org/, якщо виникнуть питання щодо конфігурування.

ЗАПУСК ПРОГРАМ

Для виклику Wine ви можете вказати повний шлях до виконуваного файлу,
або лише ім'я файлу.

Наприклад: щоб запустити Блокнот(Notepad):

text
wine notepad            (використавши шлях пошуку файлу,
wine notepad.exe         збережений в реєстрі)

wine c:\\windows\\notepad.exe      (використавши синтаксис DOS)

wine ~/.wine/drive_c/windows/notepad.exe  (використавши синтаксис Unix)

wine notepad.exe readme.txt          (виклик програми з параметрами)

Wine знаходиться в процесі розробки, тому деякі програми можуть не
працювати. Якщо станеться помилка, ви отримаєте лог збою, який
треба прикріпити до звіту про помилку при його заповненні.

ОТРИМАННЯ ДОДАТКОВОЇ ІНФОРМАЦІЇ

  • WWW: Багато інформації про Wine є в WineHQ на
    https://www.winehq.org/: різні керівництва Wine, база даних додатків,
    база даних помилок. Ймовірно найкраще почати з цього сайту.

  • FAQ Wine FAQ розташований на https://gitlab.winehq.org/wine/wine/-/wikis/FAQ

  • Wiki Wine Wiki розташована на https://gitlab.winehq.org/wine/wine/-/wikis/

  • Gitlab: https://gitlab.winehq.org

  • Списки розсилання:
    Є кілька розсилок для користувачів і розробників Wine;
    дивіться https://gitlab.winehq.org/wine/wine/-/wikis/Forums
    для додаткової інформації.

  • Помилки(баги):
    Повідомляйте про помилки у Wine Bugzilla на https://bugs.winehq.org
    Перш ніж відправляти повідомлення про помилку перевірте в базі, чи
    ця помилка вже виявлена.

  • IRC: Онлайн допомога доступна на каналі #WineHQ на irc.libera.chat.

Documentation README Zh Cn (`documentation/README-zh_cn.md`)

简介

Wine 是能够使 Microsoft Windows 程序（包括 DOS、Windows 3.x、Win32
以及 Win64 可执行程序）在 Unix 上运行的应用程序。
它包含一个用来加载并执行 Microsoft Windows 二进制程序的程序加载器，
以及一个使用 Unix 或 X11 的等价功能实现 Windows API 调用的函数库
（名称为 Winelib）。这个库也可用来将 Windows 代码移植为原生 Unix
可执行程序。

Wine 是自由软件，在 GNU LGPL 协议下发布；请查看 LICENSE 文件以了解
详情。

快速开始

当您从源代码编译时，我们建议您使用 Wine Installer 来构建、安装 Wine。
从 Wine 源代码的顶层目录开始（即包含本文件的目录[译注：指顶层的 README
文件]），运行：

text
./configure
make

运行程序时，请使用wine [程序名]的语法。如需了解更多信息或解决遇到的
问题，您可以继续阅读本文件的剩余部分，或阅读 Wine 的手册页。
需特别指出的是，您可以在网站：https://www.winehq.org 上找到十分丰富
的信息。

系统需求

要想成功编译并运行 Wine，您必须使用以下列出的操作系统之一：

  • Linux 2.6.22 或更新版本
  • FreeBSD 12.4 或更新版本
  • Solaris x86 9 或更新版本
  • NetBSD-current
  • macOS 10.15 或更新版本

鉴于运行 Wine 需要内核级别的线程支持，仅以上提及的操作系统能被支持。
其它拥有内核线程的操作系统可能在未来得到支持。

FreeBSD 信息：
请查看 https://wiki.freebsd.org/Wine 以了解更多信息。

Solaris 信息：
您大部分情况下可能需要使用 GNU 工具链（gcc、gas 等）来构建 Wine。
警告：安装 gas 不能 确保它被 gcc 所使用。您可能需要在安装 gas
之后重编译 gcc，或是将 cc、as 和 ld 符号链接至 GNU 版的对应工具。

NetBSD 信息：
请确保您在内核中启用了 USER_LDT、SYSVSHM、SYSVSEM 和 SYSVMSG 选项。

Mac OS X 信息:
您需要 Xcode/Xcode Command Line Tools 或者 Apple cctools。

支持的文件系统：
Wine 应当能在大多数文件系统上工作。有一些被报告的兼容性问题，
主要与使用 Samba 访问文件有关。另外，NTFS 不能提供一些应用所
需要的某些文件系统的特定功能。综上所述，建议您使用原生的 Unix
文件系统。

基本要求：
您需要安装 X11 开发用头文件（在 Debian 中可能被称为 xorg-dev
，在 Red Hat 中可能被称为 libX11-devel）。
当然您同样需要“make”工具（一般应当为 GNU make）。
您也需要 flex 的 2.5.33 版或更新版本，以及 bison 工具。

可选的支持库：
当可选的函数库无法在您的系统中找到时，configure 会显示对应的提示信息。
请查看 https://gitlab.winehq.org/wine/wine/-/wikis/Building-Wine 以了解您应当安装的
软件包的信息。
在 64 位平台上，如果以 32 位的方式编译 Wine（这是默认情况），您必须确保
对应函数库的 32 位版本已被安装。

编译

如果您选择不使用 wineinstall 工具，请运行下列的命令以构建 Wine：

text
./configure
make

这样将会构建“wine”程序和大量的支持库/二进制文件。
“wine”程序可以加载并运行 Windows 可执行文件。
“libwine”（“Winelib”）函数库可被用来在 Unix 下编译并链接 Windows
程序的源码。

如需查看编译配置选项，请使用./configure --help。

安装

一旦 Wine 已被正确构建，您可以进行make install；该操作将安装 wine
可执行文件、函数库、Wine 手册页以及其它需要使用的文件。

不要忘记事先卸载先前任何安装过的、会引起冲突的 Wine 软件集。
请在安装前尝试dpkg -r wine、rpm -e wine或make uninstall。

一旦安装完成，您可以运行winecfg配置工具。请参考 https://www.winehq.org/
网站中的支持页面以了解配置技巧。

运行程序

当您调用 Wine 时，您可以指定指向可执行文件的整个路径，或是仅指定文件名
信息。

例如，如需运行 Notepad：

text
wine notepad            (使用注册表中指定的搜索路径来
wine notepad.exe         定位文件)

wine c:\\windows\\notepad.exe      (使用 DOS 文件名语法)

wine ~/.wine/drive_c/windows/notepad.exe  (使用 Unix 文件名语法)

wine notepad.exe readme.txt          (带参数调用程序)

Wine 不是十全十美的，所以某些程序可能会崩溃。如果这样的情况发生，
您将会得到一份崩溃日志。您应当在提交程序漏洞时附上这份日志。

获取更多信息

--- METRICS ---

Explore Related Technologies & Topics

View All 9,111+ Repositories →

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

⚡ MCP Servers Model Context Protocol → 🧠 Agent Skills Prompt & rule files → 🔌 OpenAPI Specs REST & Swagger schemas →