ddp setup Übersetnzung (#89)

* Übersetzt

mit übersetzter geändert

* Update main.go

* Update prompt.go

ich hoffe, es funktioniert so?

* ich glaube nicht, dass das so funktioniert, verändern

* verfeinerungen

* Alle Kommentareändern zurück ins Englische

* dutzen

cmd/ddp-setup/main.go

@@ -25,23 +25,23 @@ var (
 )
 
 func exit(code int) {
-	InfoF("Press ENTER to exit...")
+	InfoF("Drücke die Eingabetaste, um das Fenster zu schließen...")
 	if !always_yes {
 		fmt.Scanln()
 	}
 	os.Exit(code)
 }
 
 func main() {
-	flag.BoolVar(&always_yes, "force", false, "always answer yes to prompts")
+	flag.BoolVar(&always_yes, "force", false, "immer ja zu Aufforderungen antworten")
 	flag.Parse()
-	if !prompt("Welcome to the DDP Installer!\nThis setup will simply unpack some files and ask you for permission to change some environment variables and such.\nDo you want to continue") {
+	if !prompt("Willkommen beim DDP-Installer!\nDieses Setup wird einige Dateien entpacken und dich um Erlaubnis fragen, einige Umgebungsvariablen zu verändern u. Ä.\nMöchtest du fortfahren") {
 		return
 	}
 
 	cwd_, err := os.Getwd()
 	if err != nil {
-		WarnF("error getting current working directory: %s", err)
+		WarnF("Fehler beim Abrufen des aktuellen Arbeitsverzeichnisses: %s", err)
 	} else {
 		cwd = cwd_
 	}
@@ -50,117 +50,117 @@ func main() {
 	_, hasGcc := LookupCommand(gccCmd)
 
 	if !hasGcc && runtime.GOOS == "windows" {
-		InfoF("gcc not found, installing mingw64")
-		InfoF("unzipping mingw64.zip")
+		InfoF("gcc nicht gefunden, installiere mingw64")
+		InfoF("Entpacke mingw64.zip")
 		err := compression.DecompressFolder("mingw64.zip", "mingw64")
 		if err != nil {
-			ErrorF("Error while unzipping mingw64: %s", err)
-			ErrorF("gcc not available, aborting")
+			ErrorF("Fehler beim Entpacken von mingw64: %s", err)
+			ErrorF("gcc nicht verfügbar, Abbruch")
 			exit(1)
 		}
-		DoneF("unzipped mingw64")
+		DoneF("mingw64 entpackt")
 
 		gccCmd, err = filepath.Abs(filepath.Join("mingw64", "bin", "gcc"))
 		if err != nil {
-			WarnF("error getting absolute Path: %s", err)
+			WarnF("Fehler beim Abrufen des absoluten Pfads: %s", err)
 		}
 		gccCmd = filepath.ToSlash(gccCmd)
 		arCmd, err = filepath.Abs(filepath.Join("mingw64", "bin", "ar"))
 		if err != nil {
-			WarnF("error getting absolute Path: %s", err)
+			WarnF("Fehler beim Abrufen des absoluten Pfads: %s", err)
 		}
 		arCmd = filepath.ToSlash(arCmd)
 		makeCmd, err = filepath.Abs(filepath.Join("mingw64", "bin", "mingw32-make"))
 		if err != nil {
-			WarnF("error getting absolute Path: %s", err)
+			WarnF("Fehler beim Abrufen des absoluten Pfads: %s", err)
 		}
 		makeCmd = filepath.ToSlash(makeCmd)
 
-		DoneF("Installed mingw64")
-		DoneF("using newly installed mingw64 for gcc, ar and make")
+		DoneF("mingw64 installiert")
+		DoneF("Verwende das neu installierte mingw64 für gcc, ar und make")
 	} else if !hasGcc && runtime.GOOS != "windows" {
-		ErrorF("gcc not found, aborting")
+		ErrorF("gcc nicht gefunden, Abbruch")
 		exit(1)
 	}
 
 	if makeCmd == "make" { // if we don't use the zipped mingw32-make
 		_, hasMake := LookupCommand(makeCmd)
 
 		if !hasMake && runtime.GOOS == "windows" {
-			InfoF("make not found, looking for mingw32-make")
+			InfoF("make nicht gefunden, suche nach mingw32-make")
 			makeCmd, hasMake = LookupCommand("mingw32-make")
 			if !hasMake {
-				ErrorF("mingw32-make not found, aborting")
+				ErrorF("mingw32-make nicht gefunden, Abbruch")
 				exit(1)
 			}
 			makeCmd = filepath.ToSlash(makeCmd)
 		} else if !hasMake && runtime.GOOS != "windows" {
-			WarnF("make not found")
+			WarnF("make nicht gefunden")
 		}
 	}
 
 	if isSameGccVersion() {
-		DoneF("gcc versions match")
+		DoneF("gcc-Versionen stimmen überein")
 	} else {
-		InfoF("re-building runtime and stdlib")
+		InfoF("Runtime und Standardbibliothek neu kompilieren")
 		recompileLibs()
 	}
 
-	if vscodeCmd, hasVscode := LookupCommand(vscodeCmd); hasVscode && prompt("Do you want to install vscode-ddp (the DDP vscode extension)") {
-		InfoF("installing vscode-ddp as vscode extension")
+	if vscodeCmd, hasVscode := LookupCommand(vscodeCmd); hasVscode && prompt("Möchtest du vscode-ddp (die DDP vscode-Erweiterung) installieren") {
+		InfoF("Installiere vscode-ddp als vscode-Erweiterung")
 		if _, err := runCmd("", vscodeCmd, "--install-extension", "DDP-Projekt.vscode-ddp", "--force"); err == nil {
-			DoneF("Installed vscode-ddp")
+			DoneF("vscode-ddp installiert")
 		}
 	}
 
-	if prompt("Do you want to set the DDPPATH environment variable") {
+	if prompt("Möchtest du die Umgebungsvariable DDPPATH setzen") {
 		if exedir, err := osext.ExecutableFolder(); err != nil {
-			WarnF("Could not retreive executable path")
+			WarnF("Ausführungspfad konnte nicht abgerufen werden")
 		} else {
-			InfoF("Setting the environment variable DDPPATH to %s", exedir)
+			InfoF("Setze die Umgebungsvariable DDPPATH auf %s", exedir)
 			if err := penv.SetEnv("DDPPATH", exedir); err != nil {
-				ErrorF("Error setting DDPPATH: %s\nConsider adding it yourself", err)
+				ErrorF("Fehler beim Setzen von DDPPATH: %s\nErwäge, es selbst hinzuzufügen", err)
 			}
 		}
 	}
 
-	if prompt("Do you want to add the DDP/bin directory to your PATH") {
+	if prompt("Möchtest du das Verzeichnis DDP/bin zu Ihrem PATH hinzufügen") {
 		if exedir, err := osext.ExecutableFolder(); err != nil {
-			WarnF("Could not retreive executable path")
+			WarnF("Ausführungspfad konnte nicht abgerufen werden")
 		} else {
 			binPath := filepath.Join(exedir, "bin")
-			InfoF("Appending %s to the PATH", binPath)
+			InfoF("Füge %s zum PATH hinzu", binPath)
 			if err := penv.AppendEnv("PATH", binPath); err != nil {
-				ErrorF("Error appending to PATH: %s\nConsider adding DDP/bin to PATH yourself", err)
+				ErrorF("Fehler beim Hinzufügen zu PATH: %s\nMöchtest du, DDP/bin selbst zu Ihrem PATH hinzuzufügen", err)
 			}
 		}
 	}
 
 	if !errored {
-		DoneF("DDP is now installed")
-		if prompt("Do you want to delete files that are not needed anymore") {
+		DoneF("DDP ist jetzt installiert")
+		if prompt("Möchtest du Dateien löschen, die nicht mehr benötigt werden") {
 			if runtime.GOOS == "windows" {
-				InfoF("deleting mingw64.zip")
+				InfoF("Lösche mingw64.zip")
 				if err := os.Remove("mingw64.zip"); err != nil {
-					WarnF("error removing mingw64.zip: %s", err)
+					WarnF("Fehler beim Entfernen von mingw64.zip: %s", err)
 				} else {
-					DoneF("removed mingw64.zip")
+					DoneF("mingw64.zip entfernt")
 				}
 			}
 		}
-		DoneF("The ddp-setup finished successfuly, you can now delete it")
+		DoneF("Die DDP-Installation wurde erfolgreich abgeschlossen, du kannst sie jetzt löschen")
 	}
 	exit(0)
 }
 
 func installLocales() {
-	InfoF("installing german locales")
+	InfoF("Installiere deutsche Lokalisierung")
 	if runtime.GOOS == "linux" {
 		if _, err := runCmd("", "locale-gen", "de_DE.UTF-8"); err != nil {
-			WarnF("error installing german locale: %s", err)
+			WarnF("Fehler bei der Installation der deutschen Lokalisierung: %s", err)
 		}
 	} else if runtime.GOOS == "windows" {
-		WarnF("you are using windows, make sure you have the correct language packs installed")
+		WarnF("Du verwendest Windows. Stell sicher, dass du die richtigen Sprachpakete installiert hast")
 	}
 }
 
@@ -178,7 +178,7 @@ func isSameGccVersion() bool {
 	kddpGccVersion := strings.Trim(strings.Split(gccVersionLine, " ")[2], "\r\n")
 	match := gccVersion == kddpGccVersion
 	if !match {
-		InfoF("local gcc version, and kddp gcc version mismatch (%s vs %s)", gccVersion, kddpGccVersion)
+		InfoF("Lokale gcc-Version und kddp-gcc-Version stimmen nicht überein (%s vs %s)", gccVersion, kddpGccVersion)
 	}
 	return match
 }
@@ -194,63 +194,63 @@ func recompileLibs() {
 	if _, err := runCmd("lib/runtime/", makeCmd, make_args...); err != nil {
 		return
 	}
-	DoneF("re-compiled the runtime")
+	DoneF("Runtime neu kompiliert")
 	if _, err := runCmd("lib/stdlib/", makeCmd, make_args...); err != nil {
 		return
 	}
-	DoneF("re-compiled the stdlib")
+	DoneF("Standardbibliothek neu kompiliert")
 
-	InfoF("removing pre-compiled runtime")
+	InfoF("Entferne vor-kompilierte Runtime")
 	if err := os.Remove("lib/libddpruntime.a"); err != nil {
-		WarnF("error removing pre-compiled runtime: %s", err)
+		WarnF("Fehler beim Entfernen der vor-kompilierten Runtime: %s", err)
 	}
-	InfoF("removing pre-compiled lib/main.o lib/ddp_list_types_defs.o lib/ddp_list_types_defs.ll")
+	InfoF("Entferne vor-kompilierte lib/main.o lib/ddp_list_types_defs.o lib/ddp_list_types_defs.ll")
 	if err := os.Remove("lib/main.o"); err != nil {
-		WarnF("error removing pre-compiled lib/main.o: %s", err)
+		WarnF("Fehler beim Entfernen der vor-kompilierten lib/main.o: %s", err)
 	}
 	if err := os.Remove("lib/ddp_list_types_defs.o"); err != nil {
-		WarnF("error removing pre-compiled lib/ddp_list_types_defs.o: %s", err)
+		WarnF("Fehler beim Entfernen der vor-kompilierten lib/ddp_list_types_defs.o: %s", err)
 	}
 	if err := os.Remove("lib/ddp_list_types_defs.ll"); err != nil {
-		WarnF("error removing pre-compiled lib/ddp_list_types_defs.ll: %s", err)
+		WarnF("Fehler beim Entfernen der vor-kompilierten lib/ddp_list_types_defs.ll: %s", err)
 	}
-	InfoF("removing pre-compiled stdlib")
+	InfoF("Entferne vor-kompilierte Standardbibliothek")
 	if err := os.Remove("lib/libddpstdlib.a"); err != nil {
-		WarnF("error removing pre-compiled stdlib: %s", err)
+		WarnF("Fehler beim Entfernen der vor-kompilierten Standardbibliothek: %s", err)
 	}
 
-	InfoF("copying re-compiled runtime")
+	InfoF("Kopiere neu kompilierte Runtime")
 	if err := cp.Copy("lib/runtime/libddpruntime.a", "lib/libddpruntime.a"); err != nil {
-		ErrorF("error copying re-compiled runtime: %s", err)
+		ErrorF("Fehler beim Kopieren der neu kompilierten Runtime: %s", err)
 	}
-	InfoF("copying re-compiled lib/main.o")
+	InfoF("Kopiere neu kompilierte lib/main.o")
 	if err := cp.Copy("lib/runtime/source/main.o", "lib/main.o"); err != nil {
-		ErrorF("error copying re-compiled runtime: %s", err)
+		ErrorF("Fehler beim Kopieren der neu kompilierten Runtime: %s", err)
 	}
-	InfoF("regenerating lib/ddp_list_types_defs.ll and lib/ddp_list_types_defs.o")
+	InfoF("Regeneriere lib/ddp_list_types_defs.ll und lib/ddp_list_types_defs.o")
 	if _, err := runCmd("", kddpCmd, "dump-list-defs", "-o", "lib/ddp_list_types_defs", "--llvm_ir", "--object"); err != nil {
-		ErrorF("error regenerating lib/ddp_list_types_defs.ll and lib/ddp_list_types_defs.o: %s", err)
+		ErrorF("Fehler bei der Regeneration von lib/ddp_list_types_defs.ll und lib/ddp_list_types_defs.o: %s", err)
 	}
-	InfoF("copying re-compiled stdlib")
+	InfoF("Kopiere neu kompilierte Standardbibliothek")
 	if err := cp.Copy("lib/stdlib/libddpstdlib.a", "lib/libddpstdlib.a"); err != nil {
-		ErrorF("error copying re-compiled stdlib: %s", err)
+		ErrorF("Fehler beim Kopieren der neu kompilierten Standardbibliothek: %s", err)
 	}
 
-	InfoF("cleaning runtime directory")
+	InfoF("Säubere das Verzeichnis Runtime")
 	clean_args := make([]string, 0, 2)
 	clean_args = append(clean_args, "clean")
 	if rmArg != "" {
 		clean_args = append(clean_args, rmArg)
 	}
 	if _, err := runCmd("lib/runtime/", makeCmd, clean_args...); err != nil {
-		WarnF("error while cleaning runtime directory: %s", err)
+		WarnF("Fehler beim Säubern des Runtime-Verzeichnisses: %s", err)
 	}
-	InfoF("cleaning stdlib directory")
+	InfoF("Säubere das Verzeichnis Standardbibliothek")
 	if _, err := runCmd("lib/stdlib/", makeCmd, clean_args...); err != nil {
-		WarnF("error while cleaning stdlib directory: %s", err)
+		WarnF("Fehler beim Säubern des Standardbibliothek-Verzeichnisses: %s", err)
 	}
 
-	DoneF("recompiled libraries")
+	DoneF("Bibliotheken neu kompiliert")
 }
 
 func runCmd(dir string, name string, args ...string) (string, error) {
@@ -260,18 +260,18 @@ func runCmd(dir string, name string, args ...string) (string, error) {
 	InfoF(cmdStr)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		ErrorF("'%s' failed (%s) output: %s", cmdStr, err, out)
+		ErrorF("'%s' fehlgeschlagen (%s) Ausgabe: %s", cmdStr, err, out)
 	}
 	return string(out), err
 }
 
 func LookupCommand(cmd string) (string, bool) {
-	InfoF("Looking for %s", cmd)
+	InfoF("Suche nach %s", cmd)
 	path, err := exec.LookPath(cmd)
 	if err == nil {
-		DoneF("Found %s in %s", cmd, path)
+		DoneF("Gefunden %s in %s", cmd, path)
 	} else {
-		WarnF("Unable to find %s", cmd)
+		WarnF("Konnte %s nicht finden", cmd)
 	}
 	return path, err == nil
 }

cmd/ddp-setup/prompt.go

@@ -13,12 +13,12 @@ var (
 )
 
 func prompt(question string) bool {
-	fmt.Print(ColorString(question+"? [y/n]: ", Cyan))
+	fmt.Print(ColorString(question+"? [j/n]: ", Cyan))
 	if always_yes {
-		fmt.Println("y")
+		fmt.Println("j")
 		return true
 	}
 	scanner.Scan()
 	answer := strings.ToLower(scanner.Text())
-	return strings.ToLower(answer) == "y"
+	return strings.ToLower(answer) == "j"
 }