WebSVN – userdetect2 – Diff – /trunk/UserDetect2/UD2_Obj.pas

 uses
   Windows, SysUtils, Classes, IniFiles, Contnrs, Dialogs, UD2_PluginIntf,
   UD2_PluginStatus, UD2_Utils, UD2_Parsing;
+const
+  UD2_TagDescription = 'Description';
 type
   TUD2IdentificationEntry = class;
   TUD2Plugin = class(TObject)
   protected
     property DetectedIdentifications: TObjectList{<TUD2IdentificationEntry>} read FDetectedIdentifications;
     destructor Destroy; override;
     constructor Create;
     function AddIdentification(IdStr: WideString): TUD2IdentificationEntry;
-    function InvokeDynamicCheck(dynamicData: WideString; var outIDs: TArrayOfString): boolean; overload;
+    function InvokeDynamicCheck(dynamicData: WideString; AErrorOut: TStrings; var outIDs: TArrayOfString): boolean; overload;
-    function InvokeDynamicCheck(dynamicData: WideString): boolean; overload;
+    function InvokeDynamicCheck(dynamicData: WideString; AErrorOut: TStrings): boolean; overload;
-    function GetDynamicRequestResult(dynamicData: WideString): TArrayOfString;
+    function GetDynamicRequestResult(dynamicData: WideString; AErrorOut: TStrings=nil): TArrayOfString;
     function EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;
   end;
   TUD2IdentificationEntry = class(TObject)
     property IniFileName: string read FIniFileName;
     property Errors: TStrings read FErrors;
     property LoadedPlugins: TObjectList{<TUD2Plugin>} read FLoadedPlugins;
     property IniFile: TMemIniFile read FIniFile;
     procedure GetAllDetectedIDs(outSL: TStrings);
-    function FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean; overload;
+    function FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): boolean; overload;
-    function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean; overload;
+    function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): boolean; overload;
-    function CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil): TUD2CommandArray;
+    function CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): TUD2CommandArray;
     function FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;
-    function GetCommandList(ShortTaskName: string): TUD2CommandArray;
+    function GetCommandList(ShortTaskName: string; AErrorOut: TStrings=nil): TUD2CommandArray;
     procedure HandlePluginDir(APluginDir, AFileMask: string);
     procedure GetTaskListing(outSL: TStrings);
     constructor Create(AIniFileName: string);
     destructor Destroy; override;
     function TaskExists(ShortTaskName: string): boolean;
     useDynamicData: boolean;
     dynamicData: WideString;
     procedure Execute; override;
     function HandleDLL: boolean;
   public
-    pl: TUD2Plugin;
+    Plugin: TUD2Plugin;
     Errors: TStringList;
     ResultIdentifiers: TArrayOfString;
     constructor Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);
     destructor Destroy; override;
   end;
   LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED    = 'Not available (Operating system not supported)';
   LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED    = 'Not available (Hardware not supported)';
   LNG_STATUS_NOTAVAIL_NO_ENTITIES         = 'Not available (No entities to identify)';
   LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE = 'Not available (A Windows API call failed. Message: %s)';
   LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC = 'Not available (Arguments required)';
+  LNG_STATUS_NOTAVAIL_INVALID_INPUT       = 'Not available (Plugin received invalid input)';
   LNG_UNKNOWN_NOTAVAIL                    = 'Not available (Unknown status code %s)';
   LNG_STATUS_FAILURE_UNSPECIFIED          = 'Error (Unspecified)';
   LNG_STATUS_FAILURE_BUFFER_TOO_SMALL     = 'Error (The provided buffer is too small!)';
-  LNG_STATUS_FAILURE_INVALID_ARGS         = 'Error (The function received invalid arguments!)';
+  LNG_STATUS_FAILURE_INVALID_ARGS         = 'Error (An internal function received invalid arguments!)';
   LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED  = 'Error (The plugin is not licensed)';
   LNG_STATUS_FAILURE_NO_RETURNED_VALUE    = 'Error (Plugin did not return a status)';
   LNG_STATUS_FAILURE_CATCHED_EXCEPTION    = 'Error (Catched unexpected Exception)';
   LNG_UNKNOWN_FAILED                      = 'Error (Unknown status code %s)';
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED, false)    then result := LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_HW_NOT_SUPPORTED, false)    then result := LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_NO_ENTITIES, false)         then result := LNG_STATUS_NOTAVAIL_NO_ENTITIES
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE, false) then result := Format(LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE, [FormatOSError(grStatus.dwExtraInfo)])
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC, false) then result := LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC
+  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_INVALID_INPUT, false)       then result := LNG_STATUS_NOTAVAIL_INVALID_INPUT
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_UNSPECIFIED, false)          then result := LNG_STATUS_FAILURE_UNSPECIFIED
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_BUFFER_TOO_SMALL, false)     then result := LNG_STATUS_FAILURE_BUFFER_TOO_SMALL
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_INVALID_ARGS, false)         then result := LNG_STATUS_FAILURE_INVALID_ARGS
   else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_PLUGIN_NOT_LICENSED, false)  then result := LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED
 begin
   inherited Create;
   FDetectedIdentifications := TObjectList{<TUD2IdentificationEntry>}.Create(true);
 end;
-function TUD2Plugin.InvokeDynamicCheck(dynamicData: WideString; var outIDs: TArrayOfString): boolean;
+function TUD2Plugin.InvokeDynamicCheck(dynamicData: WideString; AErrorOut: TStrings; var outIDs: TArrayOfString): boolean;
 var
   ude: TUD2IdentificationEntry;
   i: integer;
   id: string;
   l: integer;
   end;
   // The dynamic content was already evaluated (and therefore is already added in FDetectedIdentifications).
   if Length(outIDs) > 0 then exit;
-  outIDs := GetDynamicRequestResult(dynamicData);
+  outIDs := GetDynamicRequestResult(dynamicData, AErrorOut);
   for i := 0 to Length(outIDs)-1 do
   begin
     id := outIDs[i];
     result := true;
   end;
 end;
-function TUD2Plugin.GetDynamicRequestResult(dynamicData: WideString): TArrayOfString;
+function TUD2Plugin.GetDynamicRequestResult(dynamicData: WideString; AErrorOut: TStrings=nil): TArrayOfString;
 var
   lngID: LANGID;
-  pll: TUD2PluginLoader;
+  loader: TUD2PluginLoader;
 begin
   lngID := GetSystemDefaultLangID;
-  pll := TUD2PluginLoader.Create(false, PluginDLL, lngid, true, dynamicData);
+  loader := TUD2PluginLoader.Create(false, PluginDLL, lngid, true, dynamicData);
   try
-    pll.WaitFor;
+    loader.WaitFor;
-    result := pll.ResultIdentifiers;
+    result := loader.ResultIdentifiers;
-    if Assigned(pll.pl) then FreeAndNil(pll.pl);
+    if Assigned(AErrorOut) then
+    begin
+      AErrorOut.AddStrings(loader.Errors);
+    end;
+    // TODO: Use assign() instead? or allow TUD2PluginLoader to write the TPlugin object directly?
+    //       Should we even overwrite the current plugin data, or return the new plugin?
+    FIdentificationProcedureStatusCode := loader.plugin.IdentificationProcedureStatusCode;
+    FIdentificationProcedureStatusCodeDescribed := loader.plugin.IdentificationProcedureStatusCodeDescribed;
+    FOSNotSupportedEnforced := loader.plugin.OSNotSupportedEnforced;
+    FLoadingTime := loader.Plugin.LoadingTime;
   finally
+    if Assigned(loader.Plugin) then FreeAndNil(loader.Plugin);
-    pll.Free;
+    loader.Free;
   end;
 end;
 function TUD2Plugin.EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;
 begin
   result := SameText(IdentificationMethodName, idMethodNameOrGUID) or
             SameText(GUIDToString(PluginGUID), idMethodNameOrGUID)
 end;
-function TUD2Plugin.InvokeDynamicCheck(dynamicData: WideString): boolean;
+function TUD2Plugin.InvokeDynamicCheck(dynamicData: WideString; AErrorOut: TStrings): boolean;
 var
   dummy: TArrayOfString;
 begin
-  result := InvokeDynamicCheck(dynamicData, dummy)
+  result := InvokeDynamicCheck(dynamicData, AErrorOut, dummy)
 end;
 { TUD2IdentificationEntry }
 procedure TUD2IdentificationEntry.GetIdNames(sl: TStrings);
 constructor TUD2IdentificationEntry.Create(AIdentificationString: WideString;
   APlugin: TUD2Plugin);
 begin
   inherited Create;
+  // TODO: We need to do this, because ReadSectionValues strips the names of the name-value pairs...
+  //       We should correct ReadSectionValues...
+  // Example: DriveSerial(c:):2SHSWNHA010807 X    =calc.exe
+  // ReadSectionValues will return "DriveSerial(c:):2SHSWNHA010807 X=calc.exe"
+  AIdentificationString := Trim(AIdentificationString);
   FIdentificationString := AIdentificationString;
   FPlugin := APlugin;
 end;
 { TUD2 }
     for i := 0 to tob.count-1 do
     begin
       pluginLoader := tob.items[i] as TUD2PluginLoader;
       pluginLoader.WaitFor;
       Errors.AddStrings(pluginLoader.Errors);
-      if Assigned(pluginLoader.pl) then
+      if Assigned(pluginLoader.Plugin) then
       begin
         {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
-        if pluginLoader.pl.PluginGUIDSet then
+        if pluginLoader.Plugin.PluginGUIDSet then
         begin
-          sPluginID := GUIDToString(pluginLoader.pl.PluginGUID);
+          sPluginID := GUIDToString(pluginLoader.Plugin.PluginGUID);
           prevDLL := FGUIDLookup.Values[sPluginID];
-          if (prevDLL <> '') and (prevDLL <> pluginLoader.pl.PluginDLL) then
+          if (prevDLL <> '') and (prevDLL <> pluginLoader.Plugin.PluginDLL) then
           begin
-            Errors.Add(Format(LNG_PLUGINS_SAME_GUID, [prevDLL, pluginLoader.pl.PluginDLL]));
+            Errors.Add(Format(LNG_PLUGINS_SAME_GUID, [prevDLL, pluginLoader.Plugin.PluginDLL]));
-            pluginLoader.pl.Free;
+            pluginLoader.Plugin.Free;
           end
           else
           begin
-            FGUIDLookup.Values[sPluginID] := pluginLoader.pl.PluginDLL;
+            FGUIDLookup.Values[sPluginID] := pluginLoader.Plugin.PluginDLL;
-            LoadedPlugins.Add(pluginLoader.pl);
+            LoadedPlugins.Add(pluginLoader.Plugin);
           end;
         end
         else
         begin
-          LoadedPlugins.Add(pluginLoader.pl);
+          LoadedPlugins.Add(pluginLoader.Plugin);
         end;
         {$ELSE}
-        LoadedPlugins.Add(pluginLoader.pl);
+        LoadedPlugins.Add(pluginLoader.Plugin);
         {$ENDIF}
       end;
       pluginLoader.Free;
     end;
   finally
 function TUD2.GetTaskName(AShortTaskName: string): string;
 resourcestring
   LNG_NO_DESCRIPTION = '(%s)';
 begin
-  result := FIniFile.ReadString(AShortTaskName, 'Description', Format(LNG_NO_DESCRIPTION, [AShortTaskName]));
+  result := FIniFile.ReadString(AShortTaskName, UD2_TagDescription, Format(LNG_NO_DESCRIPTION, [AShortTaskName]));
 end;
 procedure TUD2.GetTaskListing(outSL: TStrings);
 var
   sl: TStringList;
       ude.GetIdNames(outSL);
     end;
   end;
 end;
-function TUD2.FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean;
+function TUD2.FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): boolean;
 begin
-  result := FulfilsEverySubterm(UD2_CondsToStr(conds), slIdNames);
+  result := FulfilsEverySubterm(UD2_CondsToStr(conds), slIdNames, AErrorOut);
 end;
-function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;
+function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): boolean;
 var
   i: integer;
   p: TUD2Plugin;
   cleanUpStringList: boolean;
   conds: TUD2TDFConditionArray;
   cond: TUD2TDFCondition;
   idName: string;
 begin
+  {$IFDEF NO_CONDITIONS_IS_FAILURE}
+  if idTerm = '' then
+  begin
+    SetLength(conds, 0);
+    result := false;
+    Exit;
+  end;
+  {$ENDIF}
   cleanUpStringList := slIdNames = nil;
   try
     if cleanUpStringList then
     begin
       slIdNames := TStringList.Create;
       if cond.dynamicDataUsed then
       begin
         p := FindPluginByMethodNameOrGuid(cond.idMethodName);
         if Assigned(p) then
         begin
-          if p.InvokeDynamicCheck(cond.dynamicData) then
+          if p.InvokeDynamicCheck(cond.dynamicData, AErrorOut) then
           begin
             // Reload the identifications
             slIdNames.Clear;
             GetAllDetectedIDs(slIdNames);
           end;
       Exit;
     end;
   end;
 end;
-function TUD2.GetCommandList(ShortTaskName: string): TUD2CommandArray;
+function TUD2.GetCommandList(ShortTaskName: string; AErrorOut: TStrings=nil): TUD2CommandArray;
 var
   i, j, l: integer;
   slSV, slIdNames: TStrings;
   tmpCmds: TUD2CommandArray;
 begin
     slSV := TStringList.Create;
     try
       FIniFile.ReadSectionValues(ShortTaskName, slSV);
       for i := 0 to slSV.Count-1 do
       begin
-        tmpCmds := CheckTerm(slSV.Strings[i], slIdNames);
+        tmpCmds := CheckTerm(slSV.Strings[i], slIdNames, AErrorOut);
         for j := Low(tmpCmds) to High(tmpCmds) do
         begin
           l := Length(result);
           SetLength(result, l+1);
           result[l] := tmpCmds[j];
   finally
     slIdNames.Free;
   end;
 end;
-function TUD2.CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil): TUD2CommandArray;
+function TUD2.CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil; AErrorOut: TStrings=nil): TUD2CommandArray;
 var
   slIdNamesCreated: boolean;
   ent: TUD2TDFEntry;
 begin
   SetLength(result, 0);
       slIdNames := TStringList.Create;
       GetAllDetectedIDs(slIdNames);
     end;
     if not UD2P_ParseTdfLine(idTermAndCmd, ent) then Exit;
-    if FulfilsEverySubterm(ent.ids, slIdNames) then
+    if FulfilsEverySubterm(ent.ids, slIdNames, AErrorOut) then
     begin
       result := ent.commands;
     end;
   finally
     if slIdNamesCreated then slIdNames.Free;
 constructor TUD2PluginLoader.Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);
 begin
   inherited Create(Suspended);
   dllfile := dll;
-  pl := nil;
+  Plugin := nil;
   Errors := TStringList.Create;
   lngid := alngid;
   self.useDynamicData := useDynamicData;
   Self.dynamicData := dynamicData;
 end;
       iniConfig := TIniFile.Create(sPluginConfigFile);
       try
         sOverrideGUID := iniConfig.ReadString('Compatibility', 'OverrideGUID', '');
         if sOverrideGUID <> '' then
         begin
-          pl.FPluginGUIDSet := true;
+          Plugin.FPluginGUIDSet := true;
-          pl.FPluginGUID := StringToGUID(sOverrideGUID);
+          Plugin.FPluginGUID := StringToGUID(sOverrideGUID);
           result := true;
         end;
       finally
         iniConfig.Free;
       end;
     end;
   end;
   procedure _OverwriteStatusToOSNotSupported;
   begin
-    pl := TUD2Plugin.Create;
+    Plugin := TUD2Plugin.Create;
-    pl.FPluginDLL := dllFile;
+    Plugin.FPluginDLL := dllFile;
     statusCode := UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED;
-    pl.FIdentificationProcedureStatusCode := statusCode;
+    Plugin.FIdentificationProcedureStatusCode := statusCode;
-    pl.FIdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);
+    Plugin.FIdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);
-    pl.FOSNotSupportedEnforced := true;
+    Plugin.FOSNotSupportedEnforced := true;
     result := true;
   end;
 resourcestring
   LNG_DLL_NOT_LOADED = 'Plugin DLL "%s" could not be loaded: %s';
         begin
           Errors.Add(Format(LNG_INVALID_PLUGIN, [dllFile]));
           Exit;
         end;
-        pl := TUD2Plugin.Create;
+        Plugin := TUD2Plugin.Create;
-        pl.FPluginDLL := dllFile;
+        Plugin.FPluginDLL := dllFile;
         @fDynamicIdentificationStringW := GetProcAddress(dllHandle, mnDynamicIdentificationStringW);
-        pl.FAcceptsDynamicRequests := Assigned(fDynamicIdentificationStringW);
+        Plugin.FAcceptsDynamicRequests := Assigned(fDynamicIdentificationStringW);
         fIdentificationStringW := nil;
         if useDynamicData then
         begin
-          if not pl.AcceptsDynamicRequests then
+          if not Plugin.AcceptsDynamicRequests then
           begin
             // TODO xxx: Darf hier ein fataler Fehler entstehen, obwohl dieses Szenario nur durch die INI file auftreten kann?
             // TODO (allgemein): doku
             Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnDynamicIdentificationStringW, dllFile]));
             Exit;
           if not Assigned(fPluginIdentifier) then
           begin
             Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginIdentifier, dllFile]));
             Exit;
           end;
-          pl.FPluginGUIDSet := true;
+          Plugin.FPluginGUIDSet := true;
-          pl.FPluginGUID := fPluginIdentifier();
+          Plugin.FPluginGUID := fPluginIdentifier();
         end;
         statusCode := fCheckLicense(nil);
         if statusCode.wCategory = UD2_STATUSCAT_FAILED then
         begin
           Exit;
         end;
         ZeroMemory(@buf, cchBufferSize);
         statusCode := fPluginNameW(@buf, cchBufferSize, lngID);
-             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.FPluginName := PWideChar(@buf)
+             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then Plugin.FPluginName := PWideChar(@buf)
-        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.FPluginName := ''
+        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then Plugin.FPluginName := ''
         else
         begin
           Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginNameW, dllFile]));
           Exit;
         end;
         ZeroMemory(@buf, cchBufferSize);
         statusCode := fPluginVendorW(@buf, cchBufferSize, lngID);
-             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.FPluginVendor := PWideChar(@buf)
+             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then Plugin.FPluginVendor := PWideChar(@buf)
-        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.FPluginVendor := ''
+        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then Plugin.FPluginVendor := ''
         else
         begin
           Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginVendorW, dllFile]));
           Exit;
         end;
         ZeroMemory(@buf, cchBufferSize);
         statusCode := fPluginVersionW(@buf, cchBufferSize, lngID);
-             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.FPluginVersion := PWideChar(@buf)
+             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then Plugin.FPluginVersion := PWideChar(@buf)
-        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.FPluginVersion := ''
+        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then Plugin.FPluginVersion := ''
         else
         begin
           Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginVersionW, dllFile]));
           Exit;
         end;
         ZeroMemory(@buf, cchBufferSize);
         statusCode := fIdentificationMethodNameW(@buf, cchBufferSize);
-             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.FIdentificationMethodName := PWideChar(@buf)
+             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then Plugin.FIdentificationMethodName := PWideChar(@buf)
-        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.FIdentificationMethodName := ''
+        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then Plugin.FIdentificationMethodName := ''
         else
         begin
           Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnIdentificationMethodNameW, dllFile]));
           Exit;
         end;
         end
         else
         begin
           statusCode := fIdentificationStringW(@buf, cchBufferSize);
         end;
-        pl.FIdentificationProcedureStatusCode := statusCode;
+        Plugin.FIdentificationProcedureStatusCode := statusCode;
-        pl.FIdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);
+        Plugin.FIdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);
         if statusCode.wCategory = UD2_STATUSCAT_SUCCESS then
         begin
           sIdentifier := PWideChar(@buf);
           if UD2_STATUS_Equal(statusCode, UD2_STATUS_OK_MULTILINE, false) then
           begin
             // Multiple identifiers (e.g. multiple MAC addresses are delimited via UD2_MULTIPLE_ITEMS_DELIMITER)
             SetLength(ResultIdentifiers, 0);
             ResultIdentifiers := SplitString(UD2_MULTIPLE_ITEMS_DELIMITER, sIdentifier);
             for i := Low(ResultIdentifiers) to High(ResultIdentifiers) do
             begin
-              pl.AddIdentification(ResultIdentifiers[i]);
+              Plugin.AddIdentification(ResultIdentifiers[i]);
             end;
           end
           else
           begin
-            pl.AddIdentification(sIdentifier);
+            Plugin.AddIdentification(sIdentifier);
             SetLength(ResultIdentifiers, 1);
             ResultIdentifiers[0] := sIdentifier;
           end;
         end
             _OverwriteStatusToOSNotSupported;
             Exit;
           end;
           // Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnIdentificationStringW, dllFile]));
-          Errors.Add(Format(LNG_METHOD_FAILURE, [pl.IdentificationProcedureStatusCodeDescribed, mnIdentificationStringW, dllFile]));
+          Errors.Add(Format(LNG_METHOD_FAILURE, [Plugin.IdentificationProcedureStatusCodeDescribed, mnIdentificationStringW, dllFile]));
           Exit;
         end;
         result := true;
       finally
-        if not result and Assigned(pl) then FreeAndNil(pl);
+        if not result and Assigned(Plugin) then FreeAndNil(Plugin);
         FreeLibrary(dllHandle);
       end;
     finally
       UD2_SetThreadErrorMode(bakErrorMode, nil);
       if result then
       begin
         endtime := GetTickCount;
         time := endtime - starttime;
         if endtime < starttime then time := High(Cardinal) - time;
-        pl.FLoadingTime := time;
+        Plugin.FLoadingTime := time;
       end;
     end;
   except
     // TODO: when an exception happens in a cdecl DLL, then this code is somehow not
     // executed. Probably the memory is corrupted. Anyway, a cdecl DLL shall NEVER

Subversion Repositories userdetect2

userdetect2/trunk/UserDetect2/UD2_Obj.pas – Rev 87 → 90