<\/p>\n
Wenn Sie sich mit den anderen Beiträgen dieser Reihe bis zum VBComponent-Objekt eines Moduls vorgearbeitet haben, ist es nur noch ein Katzensprung bis zur CodeMod-ule-Klasse. Damit können Sie dann die Inhalte eines VBA-Moduls auslesen und bearbeiten. Dieser Beitrag zeigt, welche Methoden die CodeModule-Klasse bietet und wie Sie diese für die verschiedenen Anwendungszwecke einsetzen können.<\/b><\/p>\nVorbereitung<\/h2>\n
Um die Elemente der Klasse VBE<\/b> nutzen zu können, benötigen Sie einen Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library<\/b>, den Sie im Verweise<\/b>-Dialog des VBA-Editors hinzufügen können (Menüeintrag Extras|Verweise<\/b>).<\/p>\nVorbereitende Beiträge<\/h2>\n
Wenn Sie erfahren wollen, wie Sie überhaupt bis zu der hier beschriebenen Klasse gelangen, helfen die folgenden Beiträge weiter:<\/p>\n
Die CodeModule<\/b>-Klasse und ihre Eigenschaften, Methoden und Auflistungen können Sie im Objektkatalog im Überblick ansehen, wenn Sie dort nach CodeModule <\/b>suchen (siehe Bild 1). Hier sehen wir neben den Elementen dieser Klasse auch, dass diese sowohl ein Unterelement von VBComponent <\/b>als auch von CodePane <\/b>ist. Als Element von VBComponent <\/b>können Sie es anlegen, und CodePane <\/b>ist die Schnittstelle zwischen dem anzeigenden Window<\/b>-Element im VBA-Editor und dem CodeModule<\/b>-Objekt, das einige Möglichkeiten für den Zugriff auf den Code über die Benutzeroberfläche ermöglicht.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_001.png\")
<\/p>\n
Bild 1: Die CodeModule-Klasse im Objektkatalog<\/span><\/b><\/p>\n Die Klasse CodeModule <\/b>bietet folgende Elemente:<\/p>\n Um das CodeModule<\/b>-Objekt eines Moduls zu referenzieren, benötigen Sie zuerst Zugriff auf das entsprechende VBComponent<\/b>-Element. Meist wollen Sie direkt auf ein bestimmtes Objekt zugreifen, dessen Namen Sie kennen. Dann können Sie dieses über die VBComponents<\/b>-Auflistung des VBProject<\/b>-Elements referenzieren.<\/p>\n Das VBComponent<\/b>-Element bietet dann über die CodeModule<\/b>-Eigenschaft die Möglichkeit des Zugriffs auf das CodeModule<\/b>-Objekt an. Im folgenden Beispiel referenzieren wir dieses und geben dann die Anzahl der Codezeilen in diesem CodeModule<\/b>-Objekt aus:<\/p>\n Mit der Export<\/b>-Methode des VBComponent<\/b>-Objekts können Sie eine Textdatei mit dessen Inhalt exportieren. Diese können Sie beispielsweise mit der AddFromFile<\/b>-Methode der CodeModule<\/b>-Klasse wieder einlesen.<\/p>\n Wie das gelingt, zeigen wir in folgendem Beispiel. Hier legen wir ein neues, leeres VBComponent<\/b>-Objekt an und nutzen dann die AddFromFile<\/b>-Methode seines CodeModule<\/b>-Objekts, um den Inhalt des exportierten Moduls in das neue Modul einzulesen:<\/p>\n Zu beachten ist hier, dass bei exportierten Modulen auch die Attribute mit exportiert werden, also zum Beispiel der Modulname.<\/p>\n Dieser wird beim Importieren in ein vorhandenes Modul dann für das übergeordnete VBComponent<\/b>-Objekt verwendet.<\/p>\n Sie können mit AddFromFile <\/b>jedoch auch Textdateien mit dem reinen Inhalt des Moduls laden.<\/p>\n Gegebenenfalls stellen Sie den Code für ein Modul in einer Textvariablen zusammen oder lesen diesen von anderer Stelle ein, beispielsweise aus einem Feld einer Datenbanktabelle. Wenn Sie den Inhalt der Variablen schnell in ein neues, leeres Modul einfügen möchten, bietet sich die Methode AddFromString <\/b>an. Diese schreibt den Code direkt in das CodeModule<\/b>-Objekt.<\/p>\n Im folgenden Beispiel stellen wir den einzufügenden Code zuvor in der Variablen strCode <\/b>zusammen und weisen diesen dann mit AddFromString <\/b>dem CodeModule<\/b>-Objekt zu:<\/p>\n Das Ergebnis finden Sie in Bild 2.<\/p>\n Bild 2: Per AddFromString initial hinzugefügter Code<\/span><\/b><\/p>\n Sie können AddFromString <\/b>auch nutzen, um Code in ein Modul einzufügen, das bereits Code enthält. Der neu einzufügende Code landet dann genau hinter der letzten Deklarationszeile im Modul.<\/p>\n Das macht Sinn, denn wenn der einzufügende Code auch im oberen Bereich Deklarationszeilen und im unteren Routinen enthält, dann gibt es weiterhin eine Trennung zwischen den Deklarationen im oberen Bereich und der Programmlogik im unteren Bereich. Die folgende Prozedur fügt eine Deklarationszeile zum bestehenden Code aus dem vorherigen Beispiel hinzu: <\/p>\n Dieser wird dann im Modul wie in Bild 3 eingefügt.<\/p>\n Bild 3: Per AddFromString nachträglich hinzugefügter Code<\/span><\/b><\/p>\n Im Beitrag Zugriff auf den VBA-Editor mit der VBE-Klasse <\/b>(www.access-im-unternehmen.de\/1350<\/b>) haben wir den Unterschied und die Zusammenhänge zwischen VBComponent<\/b>, Window <\/b>und CodePane <\/b>erläutert. Das CodePane <\/b>ist das Element, in dem das CodeModule<\/b>-Objekt im Window<\/b>-Objekt angezeigt wird.<\/p>\n Deshalb können wir vom CodeModule<\/b>-Element über die Eigenschaft CodePane<\/b> auch auf das betroffene Code-Pane<\/b>-Element zugreifen. Das CodePane<\/b>-Element referenzieren wir dabei wie folgt:<\/p>\n Welche Möglichkeiten die CodePane<\/b>-Klasse bietet, lesen Sie im Beitrag Auf VBA-Code zugreifen per CodePane <\/b>(www.access-im-unternehmen.de\/1354<\/b>).<\/p>\n Das CodePane<\/b>-Objekt hat eine Eigenart, die wir uns in den folgenden Beispielen zunutze machen wollen: Sie können das aktive CodePane<\/b>-Objekt, also den Container im aktuell aktiven VBA-Fenster mit dem CodeModule<\/b>-Objekt, auch direkt mit der Eigenschaft ActiveCodePane <\/b>der übergeordneten VBE<\/b>-Klasse referenzieren.<\/p>\n Es gibt einige Eigenschaften, mit denen Sie verschiedene Zeilenanzahlen ermitteln können.<\/p>\n Diese schauen wir uns in den nächsten Abschnitten an.<\/p>\n Am einfachsten ist das Zählen aller Zeilen. Dies erledigen wir mit der Eigenschaft CountOfLines<\/b>. Diese liefert die Anzahl der Zeilen von der ersten bis zur letzten Zeile des Moduls.<\/p>\n Wir gehen davon aus, dass das zu untersuchende Modul geöffnet ist und dass das entsprechende VBA-Fenster den Fokus hat.<\/p>\n Dann können wir nämlich ganz einfach wie folgt über den Direktbereich auf zu die untersuchenden Eigenschaften zugreifen – hier auf die Anzahl der Codezeilen:<\/p>\n <\/p>\n Die Eigenschaft CountOfLines <\/b>liefert die Anzahl der Zeilen, wobei auch solche Zeilen ohne Inhalt mitgezählt werden. In Bild 4 ist die Zeile mit dem Kommentar “09 <\/b>die letzte Zeile. Wenn wir hinter “09 <\/b>noch einmal die Eingabetaste betätigen und somit einen Zeilenumbruch hinzufügen, liefert CountOfLines <\/b>folglich den Wert 10<\/b>.<\/p>\n Bild 4: Abfragen von CodeModule-Eigenschaften per Direktbereich<\/span><\/b><\/p>\n Damit Sie Beispielmaterial haben, anhand dessen Sie die folgenden Beispiele nachvollziehen können, haben wir das Modul mdlBeispielcode <\/b>aus Bild 5 zum Projekt hinzugefügt. Mit der CountOfLines<\/b>-Eigenschaft erhalten Sie für dieses Modul den Wert 28<\/b>.<\/p>\n Bild 5: Beispielmodul<\/span><\/b><\/p>\n Die Eigenschaft CountOfDeclarationLines <\/b>liefert die Anzahl der Zeilen bis zur letzten Deklarationsanweisung im Modul. Da Sie keine Deklarationszeilen hinter der ersten Routine mehr verwenden dürfen, können Sie beide Bereiche somit sehr gut voneinander unterscheiden.<\/p>\n Im Gegensatz zu CountOfLines <\/b>kümmert sich CountOfDeclarationLines <\/b>situationsbedingt nicht um nachfolgende Leerzeilen:<\/p>\n Im Fall des Moduls aus dem Beispiel erhalten wir also folgendes Ergebnis:<\/p>\n Wenn Sie die Anzahl der Zeilen einer speziellen Prozedur ermitteln wollen, nutzen Sie die Eigenschaft ProcCountLines<\/b>. Diese Eigenschaft erwartet zwei Parameter:<\/p>\n Um diese Eigenschaft nutzen zu können, müssen Sie sowohl den Namen als auch den Typ der Prozedur kennen. Ein Beispielaufruf aus dem Direktbereich heraus lautet:<\/p>\n Warum erscheint hier der Wert 5<\/b> Weil sowohl die Kommentarzeile als auch die leeren Zeilen unmittelbar vor der untersuchten Prozedur mitgezählt werden – also alle seit dem allgemeinen Deklarationsteil oder der vorherigen Prozedur inklusive Kommentarzeilen.<\/p>\n Wenn Sie eine oder mehrere Zeilen eines Moduls ausgeben wollen, referenzieren Sie als erstes das CodeModule<\/b>-Objekt. Dann können Sie mit der Lines<\/b>-Methode gezielt den Inhalt einer oder mehrerer Zeilen gleichzeitig abfragen.<\/p>\n Im ersten Beispiel geben wir für das erste Argument der Lines<\/b>-Methode den Wert 1 <\/b>für die erste Zeile und den Wert der Eigenschaft CountOfLines <\/b>des CodeModule<\/b>-Objekts für den zweiten Parameter an. Lines <\/b>sollte hier also alle Zeilen in einem Rutsch liefern:<\/p>\n Das Ergebnis finden Sie in Bild 6.<\/p>\n Bild 6: Ausgabe aller Zeilen<\/span><\/b><\/p>\n Nun wollen wir die Prozedur inklusive Zeilennummern ausgeben. Dazu referenziert die folgende Prozedur das Modul mdlBeispielcode <\/b>und durchläuft in einer For Next<\/b>-Schleife die Zahlen von 1 <\/b>bis zu der mit der Eigenschaft CountOfLines <\/b>ermittelten Anzahl der Zeilen.<\/p>\n Dabei gibt sie jeweils den Inhalt der aktuellen Zeile im Direktbereich aus. Hier fügen wir vorn noch die Nummer der aktuellen Zeile im Format 00 <\/b>an:<\/p>\n Für die ersten paar Zeilen lautet das Ergebnis beispielsweise wie in Bild 7.<\/p>\n Bild 7: Ausgabe aller Zeilen inklusive Zeilennummern<\/span><\/b><\/p>\n Wir legen noch einen drauf und ermitteln jetzt zusätzlich noch den Namen der Prozedur der jeweiligen Zeile und geben den Typ der Prozedur aus.<\/p>\n Dazu fügen wir lediglich eine Variable des Typs vbext_ProcKind <\/b>hinzu und passen die Debug.Print<\/b>-Anweisung so an, dass sie diesmal nicht die Zeile mit der Lines<\/b>-Eigenschaft ermittelt, sondern mit ProcOfLine <\/b>den Namen der Prozedur, die sich in der jeweiligen Zeile befindet.<\/p>\n Diese Eigenschaft gibt mit dem zweiten Parameter noch den Typ der Prozedur aus:<\/p>\n Den Output dieser Prozedur für die Zeilen ab dem Beginn der ersten Zeile nach dem Deklarationsbereich erscheint wie in Bild 8.<\/p>\n Bild 8: Ausgabe aller Zeilennummern mit Prozedur und Prozedurtyp<\/span><\/b><\/p>\n Es gibt noch zwei weitere Eigenschaften, mit denen Sie Informationen speziell zu Prozeduren ermitteln können. <\/p>\n Um das besser nachvollziehen zu können, zwei Beispiele. Das erste ermittelt die Nummer der Zeile mit dem Sub<\/b>-Schlüsselwort, in diesem Fall Zeile 7<\/b>:<\/p>\n Und die Eigenschaft ProcStartLine <\/b>ermittelt die erste Zeile nach dem allgemeinen Deklarationsteil, der hier vier Zeilen lang ist – also lautet das Ergebnis 5<\/b>:<\/p>\n Die CodeModule<\/b>-Klasse bietet einige Möglichkeiten, um Zeilen hinzuzufügen, zu leeren oder zu ersetzen. Diese schauen wir uns in den folgenden Abschnitten an.<\/p>\n Am schnellsten erklärt ist die Methode DeleteLines<\/b>, mit der Sie eine oder mehrere Zeilen löschen können. Diese Methode erwartet als ersten Parameter die erste zu löschende Zeile und als zweiten die Anzahl der zu löschenden Zeilen.<\/p>\n Im folgenden Beispiel wollen wir alle überzähligen leeren Zeilen am Ende eines Moduls löschen. Eine leere Zeile nach der letzten Zeile mit Text ist übrigens immer vorhanden, damit Sie eine weitere Zeile eingeben können. Diese wird jedoch von der Eigenschaft CountOfLines <\/b>nicht erfasst.<\/p>\n Die Prozedur referenziert das Beispielmodul mdlBeispielcode <\/b>und durchläuft eine Do While<\/b>-Schleife solange, bis die letzte Zeile nicht mehr eine leere Zeichenkette enthält, also ihre Länge nicht 0 <\/b>ist.<\/p>\n Falls nicht vorhanden, fügen Sie dem Modul mdlBeispielcode <\/b>vor dem Aufruf einige leere Zeilen am Ende hinzu.<\/p>\n Innerhalb der Do While<\/b>-Schleife löscht die Methode DeleteLines <\/b>immer einen Bereich beginnend mit der letzten Zeile und mit der Länge einer Zeile:<\/p>\n Die nächste Methode heißt ReplaceLine<\/b>. Sie erwartet ebenfalls zwei Parameter. Der erste gibt die Nummer der zu ersetzenden Zeile an, der zweite den neuen Inhalt für diese Zeile.<\/p>\n Wenn Sie beispielsweise ein komplettes Modul auskommentieren wollen, können Sie das mit dieser Methode erledigen:<\/p>\n Die Prozedur durchläuft alle Zeilen eines Moduls von 1 <\/b>bis zu der mit CountOfLines <\/b>ermittelten letzten Zeile. Dabei ersetzt es mit der Replace<\/b>-Methode die jeweils aktuelle durch ein Hochkomma und den vorherigen Inhalt der Zeile.<\/p>\n Wenn Sie die Kommentare wieder entfernen wollen, brauchen Sie übrigens nur die Zeile innerhalb der For…Next<\/b>-Schleife zu ersetzen – und den Prozedurnamen:<\/p>\n Hier ersetzen wir die jeweiligen Zeilen einfach durch die aktuelle Zeile ohne das erste Zeichen, in dem sich nach dem Anwenden der Prozedur ModulAuskommentieren <\/b>die Hochkommata (\n
Das CodeModule-Objekt referenzieren<\/h2>\n
Public Sub <\/span>CodeModuleReferenzieren()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(\"mdlVBE\")\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n Debug.Print<\/span> objCodeModule.CountOfLines\r\nEnd Sub<\/span><\/pre>\nCode aus einer Textdatei hinzufügen<\/h2>\n
Public Sub <\/span>CodeModuleAddFromFile()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents.Add(vbext_ct_StdModule)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n objCodeModule.AddFromFile CurrentProject.Path & \"\\Neu.txt\"\r\nEnd Sub<\/span><\/pre>\nCode per Zeichenkette hinzufügen<\/h2>\n
Public Sub <\/span>CodeModuleAddFromString()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBComponent\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>strCode As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objVBComponent = objVBProject.VBComponents. Add(vbext_ct_StdModule)\r\n objVBComponent.Name = \"mdlAddFromString\"\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n strCode = \"Dim strTest As String<\/span>\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strCode = strCode & \"Public Sub Test()\" & vbCrLf<\/span>\r\n strCode = strCode & \" Debug.Print<\/span> \"\"Test\"\"\" & vbCrLf<\/span>\r\n strCode = strCode & \"End Sub\"\r\n objCodeModule.AddFromString strCode\r\nEnd Sub<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_002.png\")
<\/p>\nPublic Sub <\/span>CodeModuleAddMoreFromString()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>strCode As String<\/span>\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objCodeModule = objVBProject.VBComponents( \"mdlAddFromString\").CodeModule\r\n strCode = \"Dim strTest2 As String<\/span>\"\r\n objCodeModule.AddFromString strCode\r\nEnd Sub<\/span><\/pre>\n![\"Per](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_003.png\")
<\/p>\nDas CodePane-Objekt eines Moduls referenzieren<\/h2>\n
Public Sub <\/span>CodePaneReferenzieren()\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>objCodePane As <\/span>CodePane\r\n Set<\/span> objVBProject = VBE.ActiveVBProject\r\n Set<\/span> objCodeModule = objVBProject.VBComponents( \"mdlCodeModule\").CodeModule\r\n Set<\/span> objCodePane = objCodeModule.CodePane\r\n ''... Dinge mit dem CodePane erledigen\r\nEnd Sub<\/span><\/pre>\nSchneller Zugriff auf das CodeModule per CodePane<\/h2>\n
Zeilen zählen im Modul<\/h2>\n
Anzahl aller Zeilen im Modul<\/h2>\n
VBE.ActiveCodePane.CodeModule.CountOfLines\r\n 9<\/pre>\n
![\"Abfragen](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_004.png\")
<\/p>\nBeispielmodul für die folgenden Beispiele<\/h2>\n
![\"Beispielmodul\"](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_008.png\")
<\/p>\nAnzahl der Deklarationszeilen<\/h2>\n
\n
VBE.ActiveCodePane.CodeModule.CountOfDeclarationLines\r\n 4<\/pre>\n
Anzahl der Zeilen einer Prozedur<\/h2>\n
\n
VBE.ActiveCodePane.CodeModule.ProcCountLines(\"Testsub\", vbext_pk_Proc)\r\n 5 <\/pre>\n
Alle Zeilen eines Moduls ausgeben<\/h2>\n
Public Sub <\/span>AlleZeilenGleichzeitigAusgeben()\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Set<\/span> objCodeModule = VBE.ActiveVBProject. VBComponents(\"mdlBeispielcode\").CodeModule\r\n Debug.Print<\/span> objCodeModule.Lines(1, objCodeModule.CountOfLines)\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_006.png\")
<\/p>\nPublic Sub <\/span>AufEineZeileZugreifen()\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> objCodeModule = VBE.ActiveVBProject. VBComponents(\"mdlBeispielcode\").CodeModule\r\n For i = 1 To objCodeModule.CountOfLines\r\n Debug.Print<\/span> Format(i, \"00\"), objCodeModule.Lines(i, 1)\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_005.png\")
<\/p>\nProzedur einer Zeile ermitteln<\/h2>\n
Public Sub <\/span>AlleZeilenMitProzeduren()\r\n Dim <\/span>eProcType As <\/span>vbext_ProcKind\r\n ...\r\n Debug.Print<\/span> Format(i, \"00\"), objCodeModule.ProcOfLine(i, eProcType), eProcType\r\n ...\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2022_01\/pic_1353_007.png\")
<\/p>\nWeitere Eigenschaften zu Prozeduren<\/h2>\n
\n
VBE.ActiveCodePane.CodeModule.ProcBodyLine(\"TestSub\", vbext_pk_Proc)\r\n 7 <\/pre>\n
VBE.ActiveCodePane.CodeModule.ProcStartLine( \"TestSub\", vbext_pk_Proc)\r\n 5 <\/pre>\n
Mit Zeilen arbeiten<\/h2>\n
Zeilen löschen<\/h2>\n
Public Sub <\/span>LeerzeilenAmEndeLoeschen()\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Set<\/span> objCodeModule = VBE.ActiveVBProject. VBComponents(\"mdlBeispielcode\").CodeModule\r\n Do While<\/span> Len<\/span>(objCodeModule.Lines( objCodeModule.CountOfLines, 1)) = 0\r\n objCodeModule.DeleteLines objCodeModule.CountOfLines, 1\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nZeilen ersetzen<\/h2>\n
Public Sub <\/span>ModulAuskommentieren()\r\n Dim <\/span>objCodeModule As <\/span>CodeModule\r\n Dim <\/span>l As Long<\/span>\r\n Set<\/span> objCodeModule = VBE.ActiveVBProject .VBComponents(\"mdlBeispielcode\").CodeModule\r\n For l = 1 To objCodeModule.CountOfLines\r\n objCodeModule.ReplaceLine l, \"''\" & objCodeModule.Lines(l, 1)\r\n Next<\/span> l\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AlleKommentareEntfernen()\r\n ...\r\n objCodeModule.ReplaceLine l, Mid<\/span>(objCodeModule.Lines(l, 1), 2)\r\n ...\r\nEnd Sub<\/span><\/pre>\n