Warum Melsung Syntaxfehler!

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
gris77
User
Beiträge: 5
Registriert: Mittwoch 15. Juni 2005, 16:03

Freitag 24. Juni 2005, 10:02

Hallo@all,
ich habe eine Klasse geschrieben die an sich auch wunderbar funktioniert, wenn ich jedoch eine völlig unbedeutende Codezeile auskommentiere gibt er mir einen Syntaxerror. Habe auch die zugehörige *.pyc Datei gelöscht aber hier hilft dann meist nur etwas warten und dann wieder testen und zu aller überraschung geht es dann. Ist das ein Bug oder wie kann ich das beheben. Wenn das Script was auf diese Klasse zugreift beendet ist sollte doch wohl wieder der Ausgangszustand hergestellt sein :cry:

Weiß einer hier Rat?
querdenker
User
Beiträge: 424
Registriert: Montag 28. Juli 2003, 16:19
Wohnort: /dev/reality

Freitag 24. Juni 2005, 10:35

:? :? :? :?
Rate mal was ich in meinem Code stehen habe
:?: :?: :?: :?:

Wie sollen wir den darauf antworten??

mfg, querdenker
Gast

Freitag 24. Juni 2005, 13:15

Entschuldigt aber ich meinte wie ich es geschrieben habe, also wirklich unbedeutend. Im Klartext heißt das ich lösche z.B. einen Kommentar und dann geht es erstmal nicht, nach dem ich dann etwas warte geht es au einmal wieder oder ich füge irgendwo eine Leerzeile ein.
CM
User
Beiträge: 2464
Registriert: Sonntag 29. August 2004, 19:47
Kontaktdaten:

Freitag 24. Juni 2005, 13:26

Hi

... und im Klartext heißt das was querdenker gepostet hat: Poste Deinen Code und den Traceback, denn niemand kann hier hellsehen :!: (Womöglich nur ein Flüchtigskeitsfehler, aber auch den muß man erst einmal sehen.)

Gruß,
Christian
MaKi

Freitag 24. Juni 2005, 13:46

Hallo zusammen,

ich habe ein ähnliches Problem, allerdings nicht mit einer Klassem sondern mit einem einfachen Modul. Vielleicht hats ja ne ähnliche Ursache...

Wenn ich folgendes im Interpreter direkt eingebe funktioniert alles hervorragend:

>>> from ctypes import *
>>> def Connect():
... libc = cdll.LoadLibrary("d:\meineDLL.dll")
... return libc.Connect_i(0)
...
>>> Connect()
0 # das ist auch der Wert, den die Funktion aus der DLL zurückliefert
>>>

So, wenn ich das Ganze nun aber in ein eingenes File packe, nach /lib/site-packages kopiere, dann funktionierts schon nicht mehr:
(Datei heißt STIF.py)
>>> import STIF
Traceback (most recent call last) :
File "<interactive input>", line 1, in ?
File "STIF.py", line 42
return libc.Connect_i(0)
^
SyntaxError: invalid syntax
>>>

Ist vielleicht auch was ganz anderes als bei der Klasse, aber ich sehe auch keinen bedeutenden Unterschied und bekomme nen Fehler...

Liegt das vielleicht an irgendwelchen Pfadangaben ?

Gruß,
MaKi
Gast

Freitag 24. Juni 2005, 13:50

Der Code ist noch nicht aufgeräumt aber zum schauen richt es wohl, hier habe ich jetzt mal eine Leerzeile gelöscht und unten steht der Traceback!

Code: Alles auswählen

#!/usr/bin/python
# -*- coding: cp1252 -*-

import os, time, re, sys

class pathWalk:
    """
    Liest das Dateisystem aus und speichert Verz.-/Datei-Namen
    """
    def __init__( self, path, logIndexFile, logFile, compareFile, pathForFiles):
        """
        path - Verz. welches inkl. allen Unterverz. ausgelesen werden soll.
        indexFile - gibt den Bezeichner der anzulegenden Indexdatei. 
        saveFiles - legt fest ob Dateien auch ausgelesen werden sollen.
        """
               
        self.path=path
        
        # Allgemeine Log-Datei
        self.logFileName=logFile
        #self.logFile=logFile
        
        # Indexlog
        self.logIndexFileName=logIndexFile
        self.logIndexFile=logIndexFile
        
        # Zwischenspeicherindexdatei für Vergleich       
        self.compareIndexFileName=compareFile
        self.compareIndexFile=compareFile
               

        self.pathForFiles=pathForFiles
        
              
        #self.test=test
        
        
        
    def writeLog(self, entry, modus):
        if modus==0:
            #self.logFileName=str(self.logFileName)+'('+str(sys.platform)+')'
            print 'No logfile. Create new one with label : '+str(self.logFileName)
            os.chdir(self.pathForFiles)
            #self.logFile=file(self.logFileName, 'w') #Dateiobjekt erzeugen und zum schreiben öffnen
            logFile=file(self.logFileName, 'w') #Dateiobjekt erzeugen und zum schreiben öffnen
        if modus==1:
            logFile=file(self.logFileName, 'a')
            for element in entry:
                logFile.write('\n'+str(element))
                logFile.flush()
        if modus==2:
            logFile=file(self.logFileName, 'a') 
            logFile.write('\n'+str(entry))
            logFile.flush()
        if modus==3:
            logFile.close() 
    
    def courts(self,pathCourtsFile,courtsFileName):
      
        courtPLZList=[]
        pathCourtsFile=os.path.join(pathCourtsFile,courtsFileName)
                
        tempFileObject=file(str(pathCourtsFile),'r')
       
        for line in tempFileObject.readlines():
            if re.match('RG',line):
                courtPLZList.append(line[0:7])
        return courtPLZList

    def makeLogList(self,log):
      
        logList=[]
                        
        tempFileObject=file(str(log),'r')
       
        for line in tempFileObject.readlines():
            if re.match('{',line):
                logList.append(line)
                
        return logList
 
    # Pruefen, ob Pfad vorhanden (und Zugriff OK -> muss noch geschrieben werden)
    def checkIfAccess(self):
        pathValue=os.path.exists(self.path)
        # Existiert der Pfad?
        if pathValue==True:
            return 'OK'
        else:
            return
        
   
        
     # Schreibe Log-Datei
    #  - als String der Eintrag oder Liste , abhängig vom modus
    #    -> entry Bsp.: 'Erfolg'
    #  - als normaler Wert (integer)
    #    -> modus=0 das erste mal schreiben, modus=1 an bestehendes Log eine Liste von
    #       Einträgen anhängen, modus=2 an bestehendes Log einen Eintrag anhängen.    
        
        
    
        

  
            
    # Erzeuge den Vergleichsindex der später benötigt wird um festzulegen welche Dateien übertragen werden müssen 
    def getCompareIndex(self):
        self.writeCompareIndex('',0)
        entry=[]
        entry.append('#############################################################################################')
        entry.append('############################  Log für den  Vergleichsindex  #################################')
        entry.append('#############################################################################################\n\n')
        self.writeCompareIndex(entry,1)
        tempFileObject=file(str(self.logIndexFileName),'r')
        for line in tempFileObject.readlines():
            if re.match('RG',line):
                self.writeCompareIndex(line,2)
        self.writeCompareIndex('',3)
    
      # Durchlaufe Pfad und dokumentiere Verzeichnisse und Dateien
    def walk(self, courtPLZList):
        self.writeIndexLog('',0)
        self.writeIndexLog('#############################################################################################',2)
        self.writeIndexLog('############################   Log für den kompletten Index   ###############################',2)
        self.writeIndexLog('#############################################################################################\n\n',2)
        self.writeIndexLog("Zu untersuchende Gerichtspostleitzahlen :\n",2)
        self.writeIndexLog(courtPLZList,1)
        
        startTime = time.time()
        savePath=self.path
        dirs_id=0
        files_id=0     
        
        for court in courtPLZList:
            self.path=os.path.join(savePath, court)
            for root, dirs, files in os.walk(self.path):
                self.writeIndexLog('\n=====================================================',2)
                self.writeIndexLog('Searchpath :'+str(root),2)
                quantity=0
                for element in dirs:
                    quantity+=1
                self.writeIndexLog('Quantity of directories in current searchpath :'+str(quantity),2)
                dirs_id=dirs_id+quantity
                if quantity!=0:
                    self.writeIndexLog('Names of directories in current searchpath :\n',2)
                    self.writeIndexLog(dirs,1)
                else:
                    self.writeIndexLog('No directories in current searchpath!',2)    
                quantity=0
                for element in files:
                    quantity+=1
                self.writeIndexLog('Quantity of files in current searchpath :'+str(quantity),2)
                files_id=files_id+quantity
                if quantity!=0:
                    self.writeIndexLog('Names of files in current searchpath :',2)
                    self.writeIndexLog(files,4)
                else:
                    self.writeIndexLog('No files in current searchpath!',2)
                self.writeIndexLog('=====================================================',2)
        self.writeIndexLog(str(dirs_id)+' directories searched.',2)
        self.writeIndexLog(str(files_id)+' files found in this directories.',2)
        endTime = time.time()
        print 'Processing duration (only searching): %s' % (endTime - startTime)
        self.writeIndexLog('Processing duration (only searching): %s' % (endTime - startTime),2)
        self.writeIndexLog('',3)
        
     # Schreibe Vergleichsindex
    def writeCompareIndex(self,entry,modus):
        if modus==0:
            #self.compareIndexFileName=str(self.compareIndexFileName)+'('+str(sys.platform)+')'
            print 'No comparefile. Create new one with label : '+str(self.compareIndexFileName)
            os.chdir(self.pathForFiles)
            self.compareIndexFile=file(self.compareIndexFileName, 'w') #Dateiobjekt erzeugen und zum schreiben öffnen
        if modus==1:
            self.compareIndexFile=file(self.compareIndexFileName, 'a')
            for element in entry:
                self.compareIndexFile.write('\n'+str(element))
                self.compareIndexFile.flush()
        if modus==2:
            self.compareIndexFile=file(self.compareIndexFileName, 'a')
            self.compareIndexFile.write('\n'+str(entry))
            self.compareIndexFile.flush()
        if modus==3:
            self.compareIndexFile=file(self.compareIndexFileName, 'a')
            self.compareIndexFile.close() 
        if modus==5:
            return self.compareIndexFile.closed
        
    # Erzeuge Dateien für Tar-Programm
    def tarFiles(self):
        
        counter=0
        nameTarObject={}
        filesTarObject=[]
        dataContainerUnixCompareIndex=[]
        dataContainerWindowsCompareIndex=[]
        dataContainerForTar=[]
        checkIZN=0
        checkRUZ=0
             
        # Log-Eintrag, prüfen ob beide Vergleichsindexdateien vorhanden
        for element in os.listdir(self.pathForFiles):
            #print element
            #checkIZN+=1
            if re.search('IZN',element) and re.search('unix',element):
                checkIZN+=1
                compareIndexFileUnix=element
                
            if re.search('RUZ',element) and re.search('win',element):
                checkRUZ+=1
                compareIndexFileWindows=element
                
        print checkIZN
        
        print 'checkRUZ: '+str(checkRUZ)
        if  checkRUZ!=0:
            print checkIZN+checkRUZ
            
            compareIndexFileUnix=self.pathForFiles+'/'+ compareIndexFileUnix
            print  'compareIndexFileUnix : '+str(compareIndexFileUnix)
            compareIndexFileWindows=self.pathForFiles+'/'+compareIndexFileWindows
            print  'compareIndexFileWindows : '+str(compareIndexFileWindows)
            tempFileObjectUnix=file(str(compareIndexFileUnix),'r')
            tempFileObjectWindows=file(str(compareIndexFileWindows),'r')
        
            for line in tempFileObjectUnix.readlines():
                if line[0]=='R':
                    dataContainerUnixCompareIndex.append(line)
            #print 'dataContainerUnixCompareIndex\n'+str(dataContainerUnixCompareIndex)
                                                        
                                                        
            for line in tempFileObjectWindows.readlines():
                if line[0]=='R':
                    dataContainerWindowsCompareIndex.append(line)       
            #print '\ndataContainerWindowsCompareIndex\n'+str(dataContainerWindowsCompareIndex)
        else:
            entry=[]
            entry.append("ERROR : Es muß eine Vergleichsindexdatei vom IZN [...(unix)] und eine vom RUZ [...(win32)] im Verzeichnis '"+str(self.pathForFiles)+"' geben!")
            entry.append("        Die Dateien werden automatisch Plattformabhängig mit dem entsprechenden Präfix ergänzt. Also [...(unix)] für IZN und [...(win32)] für das RUZ.")
            self.writeLog(entry,1)
       
   

        
   
            
    


    def writeIndexLog(self, entry, modus):
        if modus==0:
            print 'No logindexfile. Create new one with label : '+str(self.logIndexFileName)
            os.chdir(self.pathForFiles)
            self.logFile=file(self.logIndexFileName, 'w') #Dateiobjekt erzeugen und zum schreiben öffnen
        if modus==1:
            i=-1
            for element in entry:
                if i==7:
                    i=-1
                    self.logFile.write('\n')
                    self.logFile.flush()
                i+=1
                self.logFile.write("|| "+str(element)+" || ")
                self.logFile.flush()
        if modus==2:
            self.logFile.write('\n'+str(entry))
            self.logFile.flush()
        if modus==3:
            self.logFile.close()
        if modus==4:
            for element in entry:
                self.logFile.write('\n'+str(element))
                self.logFile.flush()
        if modus==5:
            return self.logFile.closed
            
    def print_process(self,i, total, begin):
        i += 1
        tresh = total / 10
        #if tresh == 0:
         #   tresh = 1
        if i % tresh == 0:
            print "%3.i%% %4.i/%i" % ( round(float(i)/total*100), i, total)
    def tarWin( self, pathTarProgram, pathTarArchiv):
              
        startTime = time.time()
        pathTarObject=[] #'d:/TiF_Tree/RG08209/V/0039/003900'
        nameTarArchiv='' #RG30175V003900.tar'
        print 'Create Tar-Archiv ...'
                
        RG_PLZ=''
        RG_Art=''
        RG_Nr_Mod=''
        RG_Nr=''
        for line in tempFileObject.readlines():
            if line[0]=='R':
                tmpPath=''''''
                RG_PLZ='/'+str(line[0:7])
                RG_Art='/'+str(line[7])
                RG_Nr_Mod='/'+str(line[8:12])
                RG_Nr='/'+str(line[8:14])
                tmpPath=str(RG_PLZ)+str(RG_Art)+str(RG_Nr_Mod)+str(RG_Nr)
                pathTarObject.append(tmpPath)
        print 'Diese Pfade mit allen Inhalten werden getart: '
        print pathTarObject # Pfad ist relativ zu Einstiegspfad
        os.chdir(pathTarArchiv)
        date=str(time.localtime()[0])+'_'+str(time.localtime()[1])+'_'+str(time.localtime()[2])
        command='mkdir '+date
        os.system(command)
        part=date
        
        pathTarArchiv=pathTarArchiv+'/'+part+'/'
        #print pathTarArchiv
        
        os.chdir(pathTarProgram)
        #print os.getcwd()
        for tarPath in pathTarObject:
                
            RG_PLZ=str(tarPath[1:8])
            RG_Art=str(tarPath[9])
            RG_Nr=str(tarPath[16:21])
            nameTarArchiv=RG_PLZ+RG_Art+RG_Nr+'.tar'
            print 'Name: '+str(nameTarArchiv)
            command='Tar-nt.exe -cPf '+pathTarArchiv + nameTarArchiv + ' ' + str(self.path)+tarPath
            print command
            os.system(command)
        
        endTime = time.time()
        print 'Processing duration (taring): %s' % (endTime - startTime)

Traceback (most recent call last):
File "D:\ActiveState Komodo 3.1\dbgp\pythonlib\dbgp\client.py", line 1799, in runMain
self.dbg.runfile(debug_args[0], debug_args)
File "D:\ActiveState Komodo 3.1\dbgp\pythonlib\dbgp\client.py", line 1524, in runfile
h_execfile(file, args, module=main, tracer=self)
File "D:\ActiveState Komodo 3.1\dbgp\pythonlib\dbgp\client.py", line 590, in __init__
execfile(file, globals, locals)
File "E:\Skripte\classDefinitionv6.py", line 300
RG_Nr_Mod='/'+str(line[8:12])
RG_Nr='/'+str(line[8:14])
^
SyntaxError: invalid syntax

Wenn ich die Leeerzeile wieder einfüge geht es wieder ????

Danke, für eure Hilfe.
Gast

Freitag 24. Juni 2005, 15:29

HI,

habe meinen Fehler gefunden!Was für einen Editor benutzt Du denn ?
Einen, der Python versteht ? Und an welcher Stelle löscht Du die Leerzeile ?

Ich hatte nämlich das Problem, daß mein Editor keine Vernünftigen Tabulatorzeichen gesetzt hat, sondern einfach nur Leerzeichen eingefügt hat und das mochte Python nicht....

Vielleicht hast Du durch das Löschen der Leerzeile auch irgendwie an einer entscheidenden Stelle nen TAB gelöscht ?

Gruß,
MaKi
CM
User
Beiträge: 2464
Registriert: Sonntag 29. August 2004, 19:47
Kontaktdaten:

Freitag 24. Juni 2005, 15:54

Hi Leute,

Ihr vermischt hier zwei Threads!!!!!

Für Dich Maki gilt: Wir können nur raten woran es liegt, wenn Du den Code nicht zeigst. Außerdem ist das hier doch ein anderer Thread. Syntaxfehler gibt es zuhauf und man kann sie nicht alle in einem Thread abhandeln. Deine Erklärung kann nicht stimmen: Eigentlich soll man in Python sogar Leerzeichen anstelle von Tabs benutzen. Und der Editor sollte keine Rolle spielen, sofern es nur ein Texteditor ist (natürlich sollte man nicht MSWord nehmen ;-) ). Der Editor muß Python nicht "verstehen" (nehme mal an Du meinst Syntaxhighlighting aufweisen). Wenn Du also ein Problem hast, eröffne einen neuen Thread, poste Deinen Code und die Fehlermeldung!!!

Zum ersten Gast: Was siehst Du, wenn Du von Deinem Editor eigentlich unsichtbare Zeichen anzeigen läßt? Könnte es sein, daß sich da etwas verbirgt? Im Zweifelsfalle probiere mal die paar Zeilen zu löschen und neu zu schreiben (nicht etwa copy & paste!). Das ist zwar von mir jetzt nur geraten, aber wer weiß ... Oder es liegt an dem was Maki schon anspricht: Du mixt vielleicht hier Tabs mit Leerzeichen und das interpretiert Python mitunter als Grad unterschiedlicher Einrückung - man muß hier schon konsistent sein. Auch in diesem Fall solltest Du wenigstens die Einrückung löschen und so machen, wie im Rest des Skriptes.

Gruß,
Christian

edit: Einen Nonsensesatz, durch etwas Lesbares ersetzt :oops:
querdenker
User
Beiträge: 424
Registriert: Montag 28. Juli 2003, 16:19
Wohnort: /dev/reality

Samstag 25. Juni 2005, 15:26

@maki:
<GRUMMEL>
Ich haue mal in die selbe Kerbe wie CM: Thread-Klau ist nicht!
Und für Code gibt es einen extra Button.
</GRUMMEL>
MaKi hat geschrieben:Ich hatte nämlich das Problem, daß mein Editor keine Vernünftigen Tabulatorzeichen gesetzt hat, sondern einfach nur Leerzeichen eingefügt hat und das mochte Python nicht....
Nonsens...! Man sollte sich nur entscheiden, ob man Tabs oder Spaces nutzt. Man kann auch mit nur einem Leerzeichen einrücken, was allerdings eine gewisse Verschlechterung der Lesbarkeit zur Folge hat.

Die meisten IDEs bieten ja schließlich auch an, Tabs im Code immer durch Leerzeichen zu ersetzen. (WingIDE und boa z.B.)

@Gast
Wenn ich deinen Code per C'n'P aus der Code-Box hole, sehe ich dort eine wilde Vermischung von Tabs und Spaces. Großes NoNo!
An welcher Stelle entfernst du eine Leerzeile?
Hast du deinen Code mal außerhalb von Komodo gestartet? Ich habe selber eine Zeitlang mal mit dem Ding gearbeitet, auch in der 3.1 Version.
Habe es dann aber wegen diverser Widerlichkeiten unter anderem im Debug-Bereich wieder ad acta gelegt.

Hat evtl. noch ein anderes Programm Zugriff auf die Datei?
Hast du die entscheidende Funktion oder Stelle mal alleine getestet?

Weiter: Schau dir mal die Zeile 297 an:

Code: Alles auswählen

tmpPath=''''''
Was ist das? ein Array von 3 Leerstrings?
Oder sollte das eher so

Code: Alles auswählen

tmpPath=''
aussehen?


mfg, querdenker
gris77
User
Beiträge: 5
Registriert: Mittwoch 15. Juni 2005, 16:03

Montag 27. Juni 2005, 07:56

@querdenker
das hast Recht was die Variable tmp angeht, ich wollte so nur verhindern das nur ein eingeschränktes Platzangebot bereit gestelllt wird, da ich gelesen hatte das mit 6 Hochkommatar ein längerer String möglich ist.
Ja, das Problem mit dem einrücken, das wird es wohl sein Tabolator oder 4 Leerzeichnen man sollte sich entscheiden und es nicht vermischen. War mir aber entfallen das es ja diese Problematik gibt. So schön das auch für die Lesbarkeit ist mit dieser Zwangseinrückung des Codes, so muß ich doch sagen so manches mal hätte man doch gerne wieder die geschweiften Klammern und sorgt selber für die Lesbarkeit des Codes:wink:
Benutzeravatar
jens
Moderator
Beiträge: 8482
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Montag 27. Juni 2005, 08:19

gris77 hat geschrieben:...so muß ich doch sagen so manches mal hätte man doch gerne wieder die geschweiften Klammern und sorgt selber für die Lesbarkeit des Codes:wink:
Auch keinen Fall :o Wenn du deinen Editor einmal richtig eingestellt hast, gibt es an für sich keine Probleme!
SciTE zeigt dir auch an, wenn es eine vermischung von TABs und Leerzeichen gibt!

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
querdenker
User
Beiträge: 424
Registriert: Montag 28. Juli 2003, 16:19
Wohnort: /dev/reality

Montag 27. Juni 2005, 08:59

gris77 hat geschrieben: das hast Recht was die Variable tmp angeht, ich wollte so nur verhindern das nur ein eingeschränktes Platzangebot bereit gestelllt wird, da ich gelesen hatte das mit 6 Hochkommatar ein längerer String möglich ist.
Wo das denn?? Mit '''text''' kennzeichnet man einen DOC-String, der nur zur Dokumentation dient. Und unter WinXXX kannst du als Pfad sowieso nur eine bestimmte Stringlänge als Pfad nehmen(ich glaube 254 Zeichen), das kannst du so oder so locker in einen 'normale' String packen
gris77 hat geschrieben: So schön das auch für die Lesbarkeit ist mit dieser Zwangseinrückung des Codes, so muß ich doch sagen so manches mal hätte man doch gerne wieder die geschweiften Klammern und sorgt selber für die Lesbarkeit des Codes:wink:
Ja genau, der eine setzt curlies hinten an die Zeile, der nächste mittenrein und der allerletze alleinstehend in eine neue Zeile. Dann auch gerne mal mit Einrückung, mal ohne, mal gemischt....
Versuch mal, dirch durch ein C- oder PHP- oder Java-Projekt zu lesen, an dem 6 Programmierer mit unterschiedlichen Formatierungsvorlieben und Editoren / IDEs arbeiten:evil:
Kenne ich alles schon, danke hat gereicht.
Ich vermeide Curly languages seitdem wie der Teufel das Weihwasser.

mfg, querdenker
Leonidas
Administrator
Beiträge: 16024
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Montag 27. Juni 2005, 12:38

Na jetzt melde ich mich noch schnell zu Wort, obwohl ich recht verwirrt bin von den beiden gemischten Threads (und mir sicher bin, dass es ein Einrückungsfehler ist -> SciTE und vim sind gute Editoren, damit kann man arbeiten, wenn sie gut konfiguriert sind).
querdenker hat geschrieben:Wo das denn?? Mit '''text''' kennzeichnet man einen DOC-String, der nur zur Dokumentation dient.
Naja, nur ist ein wenig arg einschränkend. Damit kann man halt recht einfach Multiline-Strings machen, was auch sonst sehr praktisch sein kann.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Antworten