BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


9. ARCHIVOS.
9.8. NOMBRE DE ARCHIVOS UTF16 EN WINDOWS.
9. ARCHIVOS.
9.8. NOMBRE DE ARCHIVOS UTF16 EN WINDOWS.
9. ARCHIVOS.
9.8. NOMBRE DE ARCHIVOS UTF16 EN WINDOWS.

SIGUIENTE

SIGUIENTE

SIGUIENTE


Todas las rutinas de archivos vistos en los capítulos anteriores, cuando se usan en los S.O. Windows sólo permiten trabajar con nombre de archivos o carpetas en ASCII o una de sus variantes ANSI. Windows permite nombre de archivos o carpetas en Unicode, específicamente usando el formato UTF16, siempre y cuando el formato de la unidad de almacenamiento sea NTFS. En este capítulo se explicará como usar esa característica accediendo a las rutinas que ofrece la API de Windows, pero implementando nuestras propias rutinas en una Unidad al que llamaremos Util.pp, y que se puede descargar desde aquí: Util.zip.

Se volverán a implementar algunas de las rutinas que se vieron en el capítulo 9.6 Rutinas de archivos con un manejador de archivo y el capitulo 9.7 Procedimientos y Funciones de archivos de la Unidad Sysutils, para ello se utilizarán las siguientes rutinas y tipos de datos de la API de Windows:


CreateFileW, FindNextFileW, GetFileAttributesW, FindClose, CreateDirectoryW, MoveFileW, RemoveDirectoryW, DeleteFileW, SetCurrentDirectoryW, FileTimeToLocalFileTime, GetCurrentDirectoryW, FileTimeToSystemTime, GetFileAttributesW, WIN32_FIND_DATAW, SetFileAttributesW, FileTime, FindFirstFileW, SystemTime.


No explicaré en profundidad las rutinas que se usarán de la API de Windows, esta información detallada la pueden encontrar en la página web de microsoft msdn: http://msdn.microsoft.com/en-us/library/windows/desktop/aa364232(v=vs.85).aspx.

Estas funcionas se encuentran en la unida Windows, por lo que se deberá incluir con el uso de la palabra reservada use, en la sección de interface de la unidad. La W de estas funciones indica que son funciones diseñadas para trabajar con Unicode. Las rutinas que implementaremos son rutinas que usaran un manejador de archivo y son las siguientes:


FileCreate, SetCurrentDir, RenameFile, FileOpen, GetCurrentDir, DeleteFile, FileExists, FileGetAttr, FileAge, DirectoryExists, FileSetAttr, FileSetDate, CreateDir, FindFirst, RemoveDir, FindNext.

‒ 01. FileCreate.

FileCreate tendrá como parámetros el nombre del archivo en Unicodestring, y devolverá el manejador de archivo. Para implementar esta función se hace uso de CreateFileW. La función CreateFileW nos permite crear un archivo con su nombre en UTF16, pero este acepta sólo los tipos de datos PWidechar, por lo que el nombre que se suministre en UnicodeString, debe ser convertido a un PWidechar, simplemente se hace un solapamiento. La función FileCreate que estamos implementando devuelve un THandle, que es un longint. Se usará THandle, para poder mantener una compatibilidad a futuro ya que el manejador de archivo devuelto por CreateFileW, puede cambiar en versiones futuras, es decir no necesariamente será de tipo longint.

CreateFileW, tiene 7 parametros de los cuales sólo usaremos el primero, el segundo, el quinto y el sexto. El primer parametro es el nombre del archivo en PWidechar, el segundo parametro son las opciones de apertura del archivo, para este segundo parametro usamos las constantes GENERIC_READ y GENERIC_WRITE, unidos por el operador or, para indicarle que el archivo que se creará debe estar listo para lectura y escritura, el tercer parametro se pone a 0 y el cuarto a nil ya que no lo necesitmos, el quinto parametro nos permite indicar el comportamiento que tendra la función al acceder a un archivo o un dispositivo, en este caso le indicamos con CREATE_ALWAYS que siempre cree el archivo, borrandolo si este ya existía, el sexto parametro es para indicar los atributos del archivo que en este caso se usará FILE_ATTRIBUTE_NORMAL, que indica que es un archivo con los atributos normales es decir no será un archivo escondido o un archivo del sistema, el último y septimo parametro no lo usaremos y colocaremos un 0. La función completa quedará como sigue:


Descargar
Function FileCreate (nombre:UnicodeString):THandle;
begin  
  FileCreate := CreateFileW(PWidechar(nombre), GENERIC_READ or GENERIC_WRITE,
                            0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
end;
Código fuente 31: Implementación FileCreate.
Descargar

‒ 02. FileOpen.

Esta función tendrá los dos parámetros ya conocidos, el primero es el nombre del archivo en UnicodeString, y el segundo son los modos u opciones de apertura (fmOpenRead, fmOpenWrite, fmOpenReadWrite) que pueden ser unidos con los modos para compartir archivos (fmShareExclusive, fmShareDenyWrite, fmShareDenyRead, fmShareDenyNone), usando el operador or. Esta función hace uso de la misma función CreateFileW, cómo explique anteriormente esta tiene 7 parámetros, el primero de ellos el nombre del archivo, el segundo las opciones de apertura, el tercero que no usamos en la función FileCreate, son las opciones de compartir archivos, el cuarto tendrá nil ya que no lo necesitamos, el quinto parámetro nos permite indicar el comportamiento que tendrá la función al acceder al archivo o dispositivo, en este caso le indicamos con OPEN_EXISTING que no cree un archivo si no que abra un archivo siempre y cuando este existe, y los últimos parámetros se usarán del mismo modo como en la función FileCreate.

Para esta función es necesario separar los modos de apertura y compartir archivos, y de esa manera colocarlos en el segundo y tercer parámetro respectivamente de la función CreateFileW. Al juntar los modos de apertura con los modos de compartir archivos, estos se pasan como un longword, en donde los primeros 4 bits serán los modos de apertura, y los 4 bits siguientes serán los modos de compartir archivos. Para los modos de apertura sólo se usan los dos primeros bits, y para los modos de compartir sólo se usan 3 bits, tal como se muestra en el siguiente gráfico:

Para separar los modos de apertura se haces uso del operador and con la máscara $F, que permitirá borrar los bits que se encuentren más allá del 4 bit, del siguiente modo:

ModoApertura:=(modos and $F);

Para separar los modos de compartir archivos se hace uso del operador shr, que se encarga de desplazar 4 bits a la derecha, del siguiente modo:

ModoCompartir:=(modos shr 4);

Al separar los modos de apertura y compartir, obtendremos para los modos de apertura valores desde 0 hasta 2, y para los modos de compartir archivos los valores serán desde 0 hasta 7, pero los valores desde 5 hasta 7 no se usan.

Una vez separados estos modos hay que cambiarlos por los que corresponden con los valores que usa Windows, que se resumen en la siguiente tabla:

Modos de apertura y compartir archivos
Valores Equivalentes en la API de Windows
fmOpenRead
GENERIC_READ
fmOpenWrite
GENERIC_WRITE
fmOpenReadWrite
GENERIC_READ or GENERIC_WRITE
fmShareExclusive
0
fmShareDenyWrite
FILE_SHARE_READ
fmShareDenyRead
FILE_SHARE_WRITE
fmShareDenyNone
FILE_SHARE_READ or FILE_SHARE_WRITE

La función será como se muestra a continuación:


Descargar
Function FileOpen(nombre:unicodestring;modos:longword):THandle;
 const
  ModosApertura: array[0..2] of Longword  = (
    GENERIC_READ,
    GENERIC_WRITE,
    GENERIC_READ or GENERIC_WRITE);
  ModosCompartir: array[0..6] of Longword = (
    0,0,
    FILE_SHARE_READ,FILE_SHARE_WRITE,
    FILE_SHARE_READ or FILE_SHARE_WRITE,0,0); 
 Var ModoApertura, ModoCompartir:longword;

 Begin  
   ModoApertura:=(modos and $F);
   ModoCompartir:=(modos shr 4);
   FileOpen := CreateFileW(PWidechar(nombre),ModosApertura[ModoApertura],
                           ModosCompartir[ModoCompartir],nil,OPEN_EXISTING,
                           FILE_ATTRIBUTE_NORMAL,0);
 End;
Código fuente 32: Implementación FileOpen.
Descargar

‒ 03. FileExists.

Para implementar esta función se usara GetFileAttributesW, esta función busca el archivo y si este no existe devuelve el siguiente valor $FFFFFFFF, cuando el valor devuelto por GetFileAttributesW es diferente a $FFFFFFFF significa que el archivo existe pero se debe comprobar si este es una carpeta, verificando si el bit de carpeta esta activado, para ello usamos el operador and con FILE_ATTRIBUTE_DIRECTORY, y si este devuelve 0 significa que no es una carpeta. La función quedaría tal como se muestra a continuación:


Descargar
Function FileExists(nombre:unicodestring):Boolean;
  var Attr:longword;
 begin  
   Attr:=GetFileAttributesW(PWidechar(nombre));  
   if Attr <> $FFFFFFFF then
     FileExists:= (Attr and FILE_ATTRIBUTE_DIRECTORY) = 0
   else
     FileExists:=False;
 End;
Código fuente 33: Implementación FileExists.
Descargar

‒ 04. DirectoryExists.

Esta función es parecida a FileExists, la diferencia está en la verificación del bit de la carpeta, cuando se verifica con and y devuelve un valor distinto de 0, entonces nos indica que es una carpeta. La función será tal como se muestra a continuación:


Descargar
Function DirectoryExists(nombre:unicodestring):Boolean;
  var Attr:longword;
 begin  
   Attr:=GetFileAttributesW(PWidechar(nombre)); //INVALID_FILE_ATTRIBUTES   
   if Attr <> $FFFFFFFF then
     DirectoryExists:= (Attr and FILE_ATTRIBUTE_DIRECTORY) <> 0
   else
     DirectoryExists:=False;
 end;
Código fuente 34: Implementación DirectoryExists.
Descargar

‒ 05. CreateDir.

Esta función se implementa con la función CreateDirectoryW, el segundo parametro de esta función y simplemente se colocará nil, la implementación será como se muestra a continuación:


Descargar
Function CreateDir(nombre:unicodestring):Boolean;
Begin
  CreateDir:=CreateDirectoryW(PWidechar(nombre),nil)
End;
Código fuente 35: Implementación CreateDir.
Descargar

‒ 06. RemoveDir.

Esta función se implementa con la función RemoveDirectoryW, la implementación es muy sencilla y se muestra a continuación:


Descargar
Function RemoveDir(nombre:unicodestring):Boolean;
Begin
  RemoveDir:=RemoveDirectoryW(PWidechar(nombre))
End;
Código fuente 36: Implementación RemoveDir.
Descargar

‒ 07. SetCurrentDir.

Esta función se implementa con la función SetCurrentDirectoryW, la implementación es muy sencilla y sólo se debe indicar la ruta y trayecto de la carpeta en PWideChar, tal como se estuvo haciendo en las funciones anteriores, la función se muestra a continuación:


Descargar
Function SetCurrentDir(nombre:unicodestring):Boolean;
Begin
  SetCurrentDir:=SetCurrentDirectoryW(PWidechar(nombre));
End;
Código fuente 37: Implementación SetCurrentDir.
Descargar

‒ 08. GetCurrentDir.

Esta función se implementa con la función GetCurrentDirectoryW, el cual se usa dos veces dentro la función que estamos implementando, la primera vez es para saber la cantidad de caracteres que tendrá el directorio actual, para ello en su primer parámetro se coloca 0 y en el segundo parámetro nil. A continuación se debe crear la variable unicodestring con la cantidad de caracteres que se obtuvo anteriormente. Se vuelve a usar la función GetCurrentDirectoryW, colocando en su primer parámetro la cantidad de caracteres y en el segundo parámetro la variable unicodestring que recibirá el directorio actual, con un solapamiento a PWideChar. Si la función GetCurrentDirectoryW devuelve un valor diferente a 0 significa que la operación se realizó con éxito. A continuación la implementación de la función:


Descargar
Function GetCurrentDir:UnicodeString;
Var URuta:Unicodestring;
    long:longword; 	
Begin  
  GetCurrentDir:='';
  long:=GetCurrentDirectoryW(0,nil);
  SetLength(URuta,long);  
  if GetCurrentDirectoryW(long,PWideChar(URuta)) <> 0 then
     GetCurrentDir:=URuta;  
End;
Código fuente 38: Implementación GetCurrentDir.
Descargar

‒ 09. FileGetAttr.

Esta función se implementa con la función GetFileAttributesW, simplemente se usa la función con el nombre en Unicodestring. Implementación:


Descargar
Function FileGetAttr(nombre:UnicodeString):longword;
Begin
 FileGetAttr:=GetFileAttributesW(PWidechar(nombre));
End;
Código fuente 39: Implementación FileGetAttr.
Descargar

‒ 10. FileSetAttr.

Esta función se implementa con la función SetFileAttributesW, que es equivalente a la función FileSetAttr, pero con el uso de UnicodeString. Implementación:


Descargar
Function FileSetAttr(nombre : unicodestring; atributo:longword):longint;
 Begin
   FileSetAttr:=-1;
   if SetFileAttributesW(PWidechar(nombre),atributo) then FileSetAttr:=0
 End;
Código fuente 40: Implementación FileSetAttr.
Descargar

‒ 11. FileAge.

Para la implementación de esta función se hace uso de varias funciones, la más obvias son para abrir el archivo y luego cerrarlo, pero para obtener la fecha y hora de ultima modificación del archivo se usan varias funciones, que explicaré a continuación. GetFileTime, obtiene la fecha y hora en UTC del archivo a través del tipo de dato FileTime, esta función tiene tres parámetros el primero el manejador de archivos, el segundo parámetro devuelve la Fecha y Hora de creación del archivo, el tercero la Fecha y Hora de último acceso y le último la Fecha y Hora de la última modificación del archivo, todos estos parámetros son punteros al tipo de dato FileTime, este tipo de dato es un registro que consta de 2 campos de tipo longword que son dwLowDateTime y dwHighDateTime. El parámetro que nos interesa es el último, y se debe indicar con el operador @ para poder obtener los datos que devuelve la función.

Cómo dije anteriormente la fecha y hora devuelta del archivo es en UTC, para lo cual se debe convertir a Local, para ello se usa la función FileTimeToLocalFileTime, después se debe convertir la fecha y hora local a una variable de tipo SystemTime usando la función FileTimeToSystemTime, que es un registro que contiene la fecha y hora de manera más legible y consta de los siguientes campos: wYear, wMonth, wDayOfWeek, wDay, wHour, wMinute, wSecond, wMilliseconds. Después de todos estos pasos se debe proceder a convertir la fecha y hora a un tipo de dato double, con el uso de la función SystemTimeToDateTime que se encuentra en la unidad sysutils. La función devuelve -1 en caso no tengo éxito con la operación, en caso contrario devolverá la fecha y hora que se requiere ya convertida a un tipo de dato double. A continuación la implementación de esta función:


Descargar
Function FileAge(Nombre:Unicodestring):double;
 Var Arch:Longint;
     FechaHoraUTC,FechaHoraLocal:FileTime;
     FechaHoraS:SystemTime;     
  Begin
    FileAge:=-1;
    Arch:=FileOpen(Nombre,fmOpenReadWrite);
    if GetFileTime(Arch,nil,nil,@FechaHoraUTC) then
     Begin
       FileTimeToLocalFileTime(FechaHoraUTC,FechaHoraLocal);
       FileTimeToSystemTime(FechaHoraLocal,FechaHoraS);
       FileAge:=SystemTimeToDateTime(FechaHoraS);
     End;
    FileClose(Arch)
  End;
Código fuente 41: Implementación FileAge.
Descargar

‒ 12. FileSetDate.

Esta función tendrá dos variantes la primera que usará un manejador de archivos y la segunda que usara el nombre de un archivo en Unicodestring, una vez implementado la primera será bastante fácil de construir.

La primera variante o versión hace uso de la función SetFileTime, que se encargará de colocar la fecha y hora al archivo, es similar GetFileTime pero se usa para realizar el proceso contrario, esta función devuelve falso en caso de producirse un error.

Dentro de esta función se hace una serie de conversiones a las fecha y hora, que son el proceso contrario a lo visto en FileAge, para ello se usan las funciones DateTimeToSystemTime, para convertir de double a SystemTime, SystemTimeToFileTime para convertir SystemTime a FileTime con hora Local y LocalFileTimeToFileTime para convertir de Local a UTC. A continuación la implementación de ambas variantes de la función FileSetDate:


Descargar
Function FileSetDate(Arch:longint; FechaHora:double):Longint;
Var FechaHoraUTC,FechaHoraLocal:FileTime;
    FechaHoraS:SystemTime;
 Begin 
   FileSetDate:=0;
   DateTimeToSystemTime(FechaHora,FechaHoraS);
   SystemTimeToFileTime(FechaHoraS,FechaHoraLocal);
   LocalFileTimeToFileTime(FechaHoraLocal,FechaHoraUTC);   
   if SetFileTime(Arch,nil,nil,@FechaHoraUTC) then  FileSetDate:=GetLastError  
 End;
 
Function FileSetDate(Nombre:Unicodestring;FechaHora:double):Longint;
Var Arch:Longint;
 Begin
    Arch:=FileOpen(Nombre,fmOpenReadWrite);
    FileSetDate:=FileSetDate(Arch,FechaHora);
    FileClose(Arch)
 End;
Código fuente 42: Implementación FileSetDate.
Descargar

‒ 13. FindFirst, FindNext, FindClose.

Para la implementación de estas funciones se hace uso de los tipos de datos FileTime, SystemTime y WIN32_FIND_DATAW de la API de Windows. FileTime y SystemTime ya se explicaron en la implementación de FileAge. El tipo de dato WIN32_FIND_DATAW, es un registro muy parecido a TSearchRec, que se usa con las funciones FindFirstFileW, FindNextFileW y FindClose.

Lo primero que se debe implementar es el nuevo registro TSearchRec, que es similar que el anterior pero con la diferencia de que el campo Time será de tipo double, Name y PathOnly de tipo Unicodestring, a continuación la definición del nuevo tipo de dato:


Descargar
Type 
  TSearchRec=Record                  
               Time:Double;  //La version original usa longint
               Size: Int64;
               Attr: LongInt; //los atributos de busqueda
               Name: UnicodeString; //La version original usa String
               ExcludeAttr: LongInt;//contiene la mascara
               FindHandle: longword; 
               Mode: Longword; //no se usa
               PathOnly: UnicodeString; //no se usa
               FindData : WIN32_FIND_DATAW; 
              End;
Código fuente 43: Implementación TSearchRec.
Descargar

Los campos Mode y PathOnly no se usan, y existen sólo para mantener algo de compatibilidad con la versión original. Los campos Time, size, Attr y Name, se usan del mismo modo que el registro original, el campo ExcludeAttr se usa para realizar la búsqueda de archivos con atributos adicionales, el campo FindHandle es el manejador de búsqueda que es un longint devuelto por la función FindFirstFileW y el campo FindData es un registro de tipo WIN32_FIND_DATAW que sirve para almacenar los resultados de la búsqueda. WIN32_FIND_DATAW contiene los siguientes campos que se describen a continuación:

dwFileAttributes
De tipo Longword, se usa para almacenar los atributos del archivo.
ftCreationTime
Registro de tipo FileTime, que tiene la Hora y fecha UTC, de la creación del archivo.
ftLastAccessTime
Registro de tipo FileTime, que tiene la Hora y fecha UTC, de la última vez que se accedió al archivo.
ftLastWriteTime
Registro de tipo FileTime, que tiene la Hora y fecha UTC, de última modificación del archivo.
nFileSizeHigh
De tipo Longword, que almacena el valor alto en bytes del tamaño del archivo.
Para obtener el tamaño real del archivo se usa la siguiente fórmula:
Tamanio:=NFileSizeLow+(qword(maxdword)+1) *NFileSizeHigh
En donde maxdword es una constante que contiene el máximo valor de un longword = 4294967295
nFileSizeLow
De tipo Longword, que almacena el valor bajo en bytes del tamaño del archivo.
dwReserved0
Longword de uso reservado.
dwReserved1
Longword de uso reservado.
cFileName
Es de tipo PWideChar y contiene el nombre del archivo en Unicode.
cAlternateFileName
El nombre del archivo en formato 8.3. No se usará para esta implementación.

Las función FindFirstFileW que se usa en la API de Windows no hace búsqueda de archivos con atributos adicionales como lo hace FindFirst, para lo cual se debe crear una función BuscarCoincidencia, que se encargará de verificar que el archivo de la búsqueda coincide con los atributos adicionales. Para la verificación se debe crear la máscara, en el campo ExcludeAttr al momento de hacer la primera búsqueda (La primera búsqueda se hace con FindFirst), la máscara consiste en tener los bits a 0 de los atributos que se quieren verificar. Es decir se asignan los siguientes atributos: faReadOnly, faArchive y otros Atributos adicionales unidos con el operador or al campo ExcludeAttr de TSearchRec, después se invierten sus valores. La máscara ExcludeAttr se usa para comprobar, si el campo dwFileAttributes que contiene los atributos del archivo encontrado, tiene al menos uno de los bits de atributos de búsqueda encendido, si es que los tiene, dará como resultado 0. La función BuscarCoincidencia es como se muestra a continuación:


Descargar
Function BuscarCoincidencia(Var ResultadoBusq:TSearchRec):Boolean;
Var encontro:boolean;   
Begin
 encontro:=false; 
 BuscarCoincidencia:=false;
 While (not encontro) do
  Begin
    if (ResultadoBusq.FindData.dwFileAttributes and ResultadoBusq.ExcludeAttr)=0 then 
       Begin
         encontro:=true;
         BuscarCoincidencia:=true;
         PasarParametros(ResultadoBusq);		 
       End
    else if not FindNextFileW(ResultadoBusq.FindHandle,ResultadoBusq.FindData) then 
            encontro:=true;
  End; 
End;
Código fuente 44: Implementación BuscarCoincidencia.
Descargar

La función BuscarCoincidencia devuelve true cuando encontró el archivo que coincide con los atributos de búsqueda, en caso contrario devuelve false. Cuando encontró una coincidencia se termina el bucle while y se usa el procedimiento PasarParametros, que se encarga de pasar los datos obtenidos en el registro FindData, a los campos del registro TSearcRec. El procedimiento PasarParametros hace uso de las siguientes funciones ya vistas anteriormente: FileTimeToLocalFileTime, FileTimeToSystemTime y SystemTimeToDateTime, para realizar las conversiones de Fecha y Hora adecuadas. El procedimiento sería el siguiente:


Descargar
Procedure PasarParametros(Var ResultadoBusq:TSearchRec);
Var 
 FechaHoraArch : FileTime;     //Apunta FileTime de API Win
 FechaHoraSistema : SystemTime;  //Apunta SystemTime de API Win
Begin
  FileTimeToLocalFileTime(ResultadoBusq.FindData.ftLastWriteTime,FechaHoraArch); 
  FileTimeToSystemTime(FechaHoraArch,FechaHoraSistema);  
  ResultadoBusq.Time:=SystemTimeToDateTime(FechaHoraSistema);

  ResultadoBusq.size:=ResultadoBusq.FindData.NFileSizeLow+(qword(maxdword)+1)
                      *ResultadoBusq.FindData.NFileSizeHigh;
  ResultadoBusq.attr:=ResultadoBusq.FindData.dwFileAttributes;
  ResultadoBusq.Name:=ResultadoBusq.FindData.cFileName;
End;
Código fuente 45: Implementación PasarParametros.
Descargar

Una vez creados la función BuscarCoincidencia y el procedimiento PasarParametros, se implementan las funciones correspondientes, FindFirst, FindNext y FindClose, tal como se muestran a continuación:


Descargar
Function FindFirst(Busqueda:UnicodeString;atributos:longword;
                   Var ResultadoBusq:TSearchRec):longint;
 Begin
   ResultadoBusq.ExcludeAttr:=not(atributos or faArchive or faReadOnly);
   ResultadoBusq.FindHandle:=FindFirstFileW(PWideChar(Busqueda),ResultadoBusq.FindData);
   FindFirst:=0;
   If ResultadoBusq.FindHandle<>Invalid_Handle_value then 
      if Not BuscarCoincidencia(ResultadoBusq) then FindFirst:=GetLastError
 End;

Function FindNext(Var ResultadoBusq:TSearchRec):longint;
Begin    
  if FindNextFileW(ResultadoBusq.FindHandle,ResultadoBusq.FindData) then  
    if BuscarCoincidencia(ResultadoBusq) then FindNext:=0
  else FindNext:=GetLastError;
End;

Procedure FindClose(Var ResultadoBusq:TSearchRec);
Begin
  Windows.FindClose(ResultadoBusq.FindHandle); 
End;
Código fuente 46: Implementación FindFirst, FindNext y FindClose.
Descargar

La función FindFirst, lo primero que hace es crear la máscara y lo coloca en el campo ExcludeAttr, después usa FindfirsFileW, para realizar la primera búsqueda, esta función devuelve un dato de tipo longint que se debe asignar al campo FindHandle del registro de búsqueda, a esta función se le debe pasar el campo FindData del registro de búsqueda. Cuando el resultado de la primera búsqueda devuelve un valor distinto de Invalid_Handle_value, entonces pasa a verificar si hay un archivo que coincide con los atributos de búsqueda adicionales, usando BuscarCoincidencia, en caso no exista una coincidencia, entonces devuelve el valor del último error producido con el uso de la función GetLastError. Si la función tiene éxito devuelve 0.

La función FindNext, usa también FindNextFileW para continuar la búsqueda, esta función devuelve verdadero si encontró un archivo, en caso contrario devuelve falso, cuando encuentra un archivo este pasa el control a la función BuscarCoincidencia, si este encuentra el archivo buscado la función FindNext devolverá 0, en caso contrario devolverá el error obtenido con GetLastError.

FindClose es una función de la API de Windows y para evitar conflictos con la función FindClose de la unidad sysutils se debe colocar el nombre de la unidad Windows y después separado por un punto el nombre de la función, esto evitará que se llame a la función FindClose de la unidad sysutils.

‒ 14. RenameFile.

Su implementación consiste en encapsular la función MoveFileW.


Descargar
Function RenameFile(NombreAnt,NombreNuevo:unicodestring):Boolean;
Begin  
  RenameFile:=MoveFileW(PWideChar(NombreAnt),PWideChar(NombreNuevo));
End
Código fuente 47: Implementación RenameFile.
Descargar

‒ 15. DeleteFile.

Para su implementación se encapsula la función DeleteFileW.


Descargar
Function DeleteFile(Nombre:UnicodeString):Boolean;
Begin
  DeleteFile:=DeleteFileW(PWidechar(Nombre));
End;
Código fuente 48: Implementación DeleteFile.
Descargar

‒ 16. SetDirSeparators.

La implementación es bastante sencilla para ello se hace uso de la constante DirectorySeparator, que contiene el carácter adecuado a usarse como separador de directorios. Lo que hace esta función es verificar si la ruta con el nombre del archivo, tienen uno de estos dos caracteres / o \, y en caso lo tengan lo reemplaza por el carácter correcto, almacenado en la constante DirectorySeparator.


Descargar
Function SetDirSeparators(Nombre:UnicodeString):UnicodeString;	
     Var i:longword;
         aux:UnicodeString;
     Begin
       aux:=Nombre;
       for i:=1 to Length(aux) do
        if aux[i] in ['/','\'] then
          aux[i]:=DirectorySeparator;
       SetDirSeparators:=aux	  
     End;
Código fuente 49: Implementación SetDirSeparators.
Descargar




SIGUIENTE
SIGUIENTE
SIGUIENTE


 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.








PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.