{"id":55001313,"date":"2021-08-01T00:00:00","date_gmt":"2021-07-31T10:13:23","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1313"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"APITypen_und_Konstanten_finden_und_speichern","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/APITypen_und_Konstanten_finden_und_speichern\/","title":{"rendered":"API-Typen und -Konstanten finden und speichern"},"content":{"rendered":"

\"\"<\/p>\n

Im Beitrag „API-Funktionen finden und speichern“ haben wir gezeigt, wie Sie alle API-Deklarationen eines VBA-Projekts finden und sowohl die Daten der API-Funktion als auch die der Parameter in zwei Tabellen speichern. Zu API-Deklarationen gehören jedoch auch einige Konstanten und Typen, die beim Aufruf der API-Funktionen verwendet werden oder als Parameter der Funktionen dienen. Im Sinne des Schaffens einer Möglichkeit zum Migrieren von API-Deklarationen von 32-Bit zu 64-Bit wollen wir auch diese Elemente zunächst in entsprechenden Tabellen speichern, um diese dann per Code anzupassen und in der 64-Bit-Version auszugeben.<\/b><\/p>\n

Vorarbeiten<\/h2>\n

Im Beitrag API-Funktionen finden und speichern <\/b>(www.access-im-unternehmen.de\/1312<\/b>) haben wir bereits eine Prozedur angelegt, die alle Module einer Datenbank durchläuft und die enthaltenen API-Deklarationen ausliest. Dieser fügen wir einen weiteren Aufruf hinzu, und zwar für eine Prozedur namens FindAPITypes<\/b>:<\/p>\n

Public Sub <\/span>FindAPIDeclares()\r\n     Dim <\/span>objVBProject As <\/span>VBProject\r\n     Dim <\/span>objVBComponent As <\/span>VBComponent\r\n     Set<\/span> objVBProject = GetCurrentVBProject\r\n     For Each objVBComponent In objVBProject.VBComponents\r\n         FindAPIDeclaresInModule objVBComponent\r\n         FindAPITypes objVBComponent\r\n     Next<\/span> objVBComponent\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur FindAPITypes <\/b>und die von dieser Prozedur aufgerufenen Routinen sehen wir uns im vorliegenden Beitrag an.<\/p>\n
Wie sind Type-Konstrukte aufgebaut<\/h2>\n
Bevor wir Code programmieren können, mit denen wir Type<\/b>-Elemente einlesen, müssen wir uns erst einmal ansehen, wie diese Elemente aufgebaut sind. Ein Type<\/b>-Element besteht immer mindetens aus dem Type<\/b>-Schlüsselwort und dem Namen des Types in der ersten Zeile, einem Element, das aus dem Elementnamen, dem Schlüsselwort As <\/b>und dem Variablentyp besteht, und dem Abschluss mit der Zeile End Type<\/b>:<\/p>\n
Type bla\r\n     blub As String<\/span>\r\nEnd Type<\/pre>\n
Das Type<\/b>-Element kann in der ersten Zeile auch noch ein Schlüsselwort enthalten, das die Gültigkeit bezeichnet, also Private <\/b>oder Public<\/b>. <\/p>\n
Eines der im Type-Konstrukt enthaltenen Elemente mit dem Datentyp String <\/b>kann auch noch die Angabe einer festen Zeichenanzahl enthalten, zum Beispiel mit der Zeichenanzahl 50<\/b>:<\/p>\n
blub As String<\/span> * 50<\/pre>\n
Ein praktisches Beispiel ist das folgende:<\/p>\n
Private <\/span>Type shellBrowseInfo\r\n     hwndOwner      As Long<\/span>\r\n     pIDLRoot       As Long<\/span>\r\n     pszDisplayName As Long<\/span>\r\n     lpszTitle      As String<\/span>\r\n     ulFlags        As Long<\/span>\r\n     lpfnCallback   As Long<\/span>\r\n     lParam         As Long<\/span>\r\n     iImage         As Long<\/span>\r\nEnd Type<\/pre>\n
Typen in VBA-Modulen finden<\/h2>\n
In der oben vorgestellten Prozedur namens FindAPIDeclares <\/b>durchlaufen wir alle VBComponent<\/b>-Objekte, also alle Module des aktuellen VBA-Projekts. Für jedes Modul rufen wir einmal die Prozedur FindAPITypes <\/b>auf und übergeben dieser einen Verweis auf das jeweilige Modul:<\/p>\n
FindAPITypes objVBComponent<\/pre>\n
Die Prozedur FindAPITypes<\/b> finden Sie in Listing 1. Die Prozedur nimmt das VBComponent<\/b>-Objekt mit dem Parameter objVBComponent <\/b>entgegen und füllt die Variable objCodeModule <\/b>mit dem Objekt aus der Eigenschaft CodeModule <\/b>der VBA-Komponente aus objVBComponent<\/b>.<\/p>\n
Public Sub <\/span>FindAPITypes(objVBComponent As <\/span>VBComponent)\r\n     Dim <\/span>objCodeModule As <\/span>CodeModule\r\n     Dim <\/span>lngLine As Long<\/span>\r\n     Dim <\/span>strLine As String<\/span>\r\n     Dim <\/span>strType As String<\/span>\r\n     Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n     For lngLine = 1 To objCodeModule.CountOfDeclarationLines\r\n         strLine = Trim<\/span>(objCodeModule.Lines(lngLine, 1))\r\n         strLine = ReplaceMultipleSpaces(strLine)\r\n         If <\/span>Left<\/span>(strLine, 5) = \"Type \" Or Left<\/span>(strLine, 13) = \"Private Type \" Or Left<\/span>(strLine, 12) = \"Public Type \" Then<\/span>\r\n             strType = strLine & vbCrLf<\/span>\r\n             Do While<\/span> Not<\/span> Left<\/span>(strLine, 8) = \"End Type\"\r\n                 lngLine = lngLine + 1\r\n                 strLine = Trim<\/span>(objCodeModule.Lines(lngLine, 1))\r\n                 strLine = ReplaceMultipleSpaces(strLine)\r\n                 strType = strType & strLine & vbCrLf<\/span>\r\n             Loop<\/span>\r\n             SaveAPIType strType, objVBComponent.Name\r\n         End If<\/span>\r\n     Next<\/span> lngLine\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Prozedur zum Finden der API-Type-Strukturen<\/span><\/b><\/p>\n
Dann durchlaufen wir alle Zeilen des Deklarationsbereichs des jeweils aktuellen Moduls aus objCodeModule<\/b> in einer For Next<\/b>-Schleife von der Zeile 1 <\/b>bis zu der mit CountOfDeclaration <\/b>ermittelten letzten Zeile des Deklarationsbereichs. Hier übertragen wir die aktuelle Zeile, von der wir mit der Trim<\/b>-Funktion überschüssige Leerzeichen vorn und hinten entfernen, in die Variable strLine<\/b>. Diese schicken wir dann durch die Funktion ReplaceMultipleSpaces<\/b>. Damit wollen wir überschüssige Leerzeichen aus der aktuellen Zeile entfernen, sodass aus der Zeile<\/p>\n
Private <\/span>Type       Beispiel<\/pre>\n
die folgende Zeile wird:<\/p>\n
Private <\/span>Type Beispiel<\/pre>\n
Die dazu verwendete Funktion ReplaceMultipleSpaces <\/b>sieht wie folgt aus und durchläuft solange eine Do While<\/b>-Schleife, bis keine doppelten Leerzeichen mehr in der mit dem Parameter strLine <\/b>übergebenen Zeichenkette enthalten sind. Innerhalb der Do While<\/b>-Schleife ersetzt die Funktion jeweils ein doppeltes Leerzeichen durch ein einfaches Leerzeichen. Anschließend gibt sie die Zeichenkette aus strLine <\/b>als Rückgabewert der Funktion zurück:<\/p>\n
Public Function <\/span>ReplaceMultipleSpaces( ByVal strLine As String<\/span>) As String<\/span>\r\n     Do While<\/span> Not<\/span> InStr<\/span>(1, strLine, \"  \") = 0\r\n         strLine = VBA.Replace<\/span>(strLine, \"  \", \" \")\r\n     Loop<\/span>\r\n     ReplaceMultipleSpaces = strLine\r\nEnd Function<\/span><\/pre>\n
Die so behandelte Zeile landet in der aufrufenden Prozedur wieder in der Variablen strLine<\/b>. Nachdem diese nun keine führenden oder folgenden Leerzeichen mehr aufweist, können wir die aktuelle Zeile dahingehend überprüfen, ob diese die erste Zeile eines Type<\/b>-Konstrukts ist.<\/p>\n
Dafür testen wir, ob die ersten fünf Zeichen der Zeichenkette „Type „<\/b>, die ersten dreizehn Zeichen der Zeichenkette „Private Type “ <\/b>oder die ersten zwölf Zeichen der Zeichenkette „Public Sub “ <\/b>lauten. Ist das der Fall, fügen wir der Variablen strType <\/b>die erste Zeile des Type<\/b>-Konstrukts inklusive eines Zeilenumbruchs hinzu.<\/p>\n
Danach durchlaufen wir solange eine Do While<\/b>-Schleife, bis wir auf eine Zeile stoßen, die mit der Zeichenfolge End Type <\/b>beginnt – also bis zur letzten Zeile des Type<\/b>-Konstrukts. Dabei erhöhen wir die Zählervariable lngLine <\/b>jeweils um 1 <\/b>und lesen die jeweilige Zeile aus objCodeModule.Lines(lngLine, 1) <\/b>in die Variable strLine <\/b>ein.<\/p>\n
In dieser Zeile entfernen wir wieder mit der Funktion ReplaceMultipleSpaces <\/b>überflüssige Leerzeichen. Den Grund dafür erfahren Sie übrigens weiter unten. Danach fügen wir die bereinigte aktuelle Zeile als neue Zeile an die Zeichenkette strType <\/b>an und hängen noch ein vbCrLf <\/b>hinten an.<\/p>\n
Dies alles geschieht, wie oben bereits beschrieben, bis wir in strLine<\/b> den Ausdruck End Type <\/b>finden. Damit ist das Type<\/b>-Konstrukt komplett in die Variable strType <\/b>eingelesen. Dieses übergeben wir dann nebst dem Namen der VBA-Komponente an eine weitere Prozedur namens SaveAPIType<\/b>.<\/p>\n
Tabelle zum Speichern der Type-Elemente anlegen<\/h2>\n
Um die Type<\/b>-Konstrukte beziehungsweise deren Informationen zu speichern, verwenden wir zwei Tabellen. Die Erste heißt tblAPITypes <\/b>und sieht in der Entwurfsansicht wie in Bild 1 aus. Die Felder speichern die folgenden Informationen:<\/p>\n
\"Entwurf<\/p>\n
Bild 1: Entwurf der Tabelle tblAPITypes<\/span><\/b><\/p>\n