[[Al González]]

Código Delphi [-]
  { PWideChar }
  Function ghPWideChr (Const S :WideString) :PWideChar;
  Asm
    Test EAX, EAX
    JNZ @Exit
    Mov EAX, ghEmptyPWideChr
    @Exit:
  End;

ghPWideChr es una función para convertir una cadena normal a una cadena de caracteres WideChar terminada en nulo. Eso mismo puede conseguirse con una expresión como "PWideChar (WideString (Cadena))" pero es más concisa (tanto en código fuente como en código máquina) una expresión "ghPWideChr (Cadena)".

Código Delphi [-]
  { Get Class ID }
  Function ghGetClassID (Const ProgID :String; Out ID :TGUID) :Integer;
  Begin
    Result := CLSIDFromProgID (ghPWideChr (ProgID), ID);
  End;

ghGetClassID envuelve a la función CLSIDFromProgID del sistema operativo, haciendo por nosotros la conversión del ProgID de tipo String a PWideChar (usando la función ghPWideChr). Obtiene el identificador de clase que corresponde a un ProgID dado.

Código Delphi [-]
  { Get Programmatic ID }
  Function ghGetProgID (Const ClassID :TGUID; Out ProgID :String) :Integer;
  Var
    AProgID :POLEStr;
  Begin
    Result := ProgIDFromCLSID (ClassID, AProgID);

    If Result = S_OK Then
    Begin
      ProgID := AProgID;
      CoTaskMemFree (AProgID);
    End;
  End;

ghGetProgID es la función inversa a ghGetClassID. Dado un identificador de clase (parámetro ClassID) obtiene el ProgID que le corresponde mediante la función ProgIDFromCLSID del sistema operativo.

Código Delphi [-]
  { Programmatic ID }
  Function ghProgID (Const ClassID :TGUID) :String;
  Begin
    ghGetProgID (ClassID, Result);
  End;

ghProgID envuelve a ghGetProgID con el propósito de que el resultado de la función sea el ProgID obtenido en lugar de un valor de estado. Si el CLSID dado no está en el Registro, el resultado será una cadena vacía (en virtud de que la variable Result es usada como parámetro Out para ghGetProgID).

Código Delphi [-]
  { Right Digits and Dots }
  Function ghRightDigitsDots (Const Value :String;
    Const MaxLength :Integer = MaxInt) :String;
  Begin
    Result := ghRightChrs (Value, ghchDotDecimals, MaxLength);
  End;

La función ghRightDigitsDots toma una cadena de caracteres y regresa la subcadena que en su extremo derecho se componga de dígitos decimales y puntos (dando 'MSXML2.DOMDocument.4.0' devuelve '.4.0').

Código Delphi [-]
  { Right Version }
  Function ghRightVersion (Const Value :String;
    Const MaxLength :Integer = MaxInt) :String;
  Begin
    Result := ghNotPrefixed (ghRightDigitsDots (Value, MaxLength), '.');
  End;

La función ghRightVersion, toma una cadena de caracteres y regresa la subcadena que en su extremo derecho se componga de dígitos decimales y puntos (para ello llama a ghRightDigitsDots), pero descarta el primer carácter de la subcadena en caso de ser un punto para que ésta siempre comience con número (dando 'MSXML2.DOMDocument.4.0' devuelve '4.0').

Código Delphi [-]
  { Programmatic ID Version }
  Function ghProgIDVersion (Const ClassID :TGUID) :String;
  Begin
    Result := ghRightVersion (ghProgID (ClassID));
  End;

ghProgIDVersion es una función que combina a ghProgID con ghRightVersion. Sirve para obtener la versión de un identificador de clase COM (parámetro ClassID) con base al ProgID que ese identificador tenga asociado en el registro de Windows.

Código Delphi [-]
  { Class ID }
  Function ghClassID (Const ProgID :String) :TGUID; Overload;
  Begin
    ghGetClassID (ProgID, Result);
  End;

ghClassID envuelve a ghGetClassID con el propósito de que el resultado de la función sea el identificador de clase obtenido en lugar de un valor de estado. Si el ProgID dado no está en el Registro, el resultado será un GUID en blanco (con todos sus bytes en cero).

Código Delphi [-]
  { Class ID }
  Function ghClassID (Const ProgID, Version :String) :TGUID; Overload;
  Begin
    Result := ghClassID (ghConcat (ProgID, Version, '.'));
  End;

Esta sobrecarga de ghClassID permite indicar un sufijo de versión para el ProgID dado. Si se da 'MSXML2.DOMDocument' y '6.0', se buscará el CLSID de 'MSXML2.DOMDocument.6.0'. Si se da 'MSXML2.DOMDocument' y '' (cadena vacía en el parámetro Version), se buscará el CLSID de 'MSXML2.DOMDocument'. Esto resulta útil dado que muchos ProgIDs pueden o no pueden tener un sufijo de versión.

Código Delphi [-]
  { Class ID }
  Function ghClassID (Const ProgID :String; Const VersionID :TGUID) :TGUID;
    Overload;
  Begin
    Result := ghClassID (ProgID, ghProgIDVersion (VersionID));
  End;

Esta otra sobrecarga de ghClassID es muy similar a la anterior, salvo que la cadena de versión se obtiene de un identificador de clase ya conocido (parámetro VersionID). Es decir, esta función obtiene el CLSID que corresponde a un ProgID cuya versión es igual a la del ProgID de otro CLSID. El actual código de TghXMLDoc no necesita llamar a esta sobrecarga, pero es probable que resulte útil a quienes deseen acceder a más objetos de MSXML (además de DOMDocument y XMLSchemaCache).

Código Delphi [-]
  { MSXML Schema Cache Class ID }
  Function ghMSXMLSchemaCacheClassID (Const VersionID :TGUID) :TGUID;
  Var
    I :Integer;
  Begin
    I := ghPosGUID (ghMSXMLDocClassIDs, VersionID);

    If I > -1 Then
      Result := ghMSXMLSchemaCacheClassIDs [i]
    Else
      Result := ghClassID ('MSXML2.XMLSchemaCache', VersionID);
  End;

La función ghMSXMLSchemaCacheClassID sirve para obtener el identificador de clase COM del objeto XMLSchemaCache de MSXML según la versión de otro identificador de clase COM (parámetro VersionID). El uso típico es darle uno de los CLSIDs de DOMDocument para obtener el correspondiente CLSID de XMLSchemaCache. La función llama a ghPosGUID para determinar si VersionID está en la constante matriz ghMSXMLDocClassIDs, en cuyo caso devuelve el GUID contenido en la misma posición de la constante matriz ghMSXMLSchemaCacheClassIDs. Observen que como último recurso se apoya en la función ghClassID descrita anteriormente. Usando TghXMLDoc no entrará a ese Else, a menos que el programador fuerce a la clase a usar una versión de MSXML que no sea vigente.

Código Delphi [-]
  { MSXML Schema Cache }
  Function ghMSXMLSchemaCache (Const VersionClassID :TGUID) :IDispatch;
  Begin
    Result := ghCOMDispatch (ghMSXMLSchemaCacheClassID (VersionClassID));
  End;

ghMSXMLSchemaCache combina una llamada a ghMSXMLSchemaCacheClassID con una llamada a ghCOMDispatch. Con ello crea una instancia de objeto XMLSchemaCache de la misma versión de MSXML que el CLSID indicado (parámetro VersionClassID). El método TghXMLDoc.AddSchema (mostrado más abajo) llama directamente a esta función cuando se agrega el primer esquema de validación.

Código Delphi [-]
  { MSXML Version }
  Function ghMSXMLVersion (Const ClassID :TGUID) :String;
  Var
    I :Integer;
  Begin
    I := ghPosGUID (ghMSXMLDocClassIDs, ClassID);

    If I > -1 Then
      Result := ghMSXMLVersions [i]
    Else
      Result := ghProgIDVersion (ClassID);
  End;

ghMSXMLVersion es la última de las funciones sueltas que escribí en esta fase de desarrollo. Sirve para obtener la versión de un identificador de clase MSXML según el ProgID que tenga asociado. Esta rutina, antes de apoyarse en la función ghProgIDVersion descrita líneas arriba, verifica si el CLSID dado se encuentra en la matriz ghMSXMLDocClassIDs, en cuyo caso regresa una de las cadenas de la matriz ghMSXMLVersions. De último momento, viendo su código, creo que debería hacerle una de dos cosas: a) renombrarla por "ghMSXMLDocVersion" (y que se llame sólo con CLSIDs de DOMDocument), o b) Hacer que busque también en la matriz ghMSXMLSchemaCacheClassIDs (evitando búsquedas en el Registro cuando se llame con CLSIDs de XMLSchemaCache). La necesidad de esta función surgió al agregar la propiedad Version a TghXMLDoc (ver más abajo).