Boletín Pascal #45 - 11-MAR-2003
Índice
1. Unas palabras del editor
2. Administrador de depuración avanzado (manejador de excepciones)
Como implementar una clase Debug que muestre el nombre de la unidad,
el nombre de la función y el número de línea de una excepción
3. Interceptando mensajes de Windows en componentes no visuales
Como hacer que un componente sin ventana reciba mensajes de Windows
4. Asocie su programa con extensiones de archivo
Como hacer asociaciones de archivo a sus ejecutables
5. Inline Assembler en Delphi (VII) - Aritmética entera de 128 bits (1)
6. Foros / listas de correo
7. Delphi en la Red
- Componentes, librerías y aplicaciones
· Shareware
· Freeware
· Actualizaciones de Delphi
- Artículos, trucos y consejos
· Kylix, CLX y Linux
- Tutoriales
- Otros enlaces
- Noticias
________________________________________________________________________
1. Unas palabras del editor
Me gustaría agradecer a Olivier Rogier, Peter Johnson, e Igor Siticov
por contribuir artículos para esta edición, y me complace entregarles
los premios para esta edición a los dos primeros:
* Olivier Rogier (Administrador de depuración avanzado...)
· SDL Component Suite 7.0 - por Software Development Lohninger ($99)
La SDL Component Suite provee un amplio rango de componentes para la
ciencia y la ingeniería, por ejemplo matemáticas, estadísticas,
química, diagramas, visualización de datos, transformadas de Fourier
(FFT), ploteos 3D, mapas geográficos, ajuste de curvas, etc.
Disponible para Delphi 3-7 y BCB 4-6.
http://www.lohninger.com/sdlindex.html
* Peter Johnson (Interceptando mensajes de Windows en componentes...)
· LMD DesignPack - por LMD Innovative - Shareware (EUR 59)
Cinco componentes para agregar características de diseño a sus
aplicaciones (un clon del Inspector de Objetos, un diseñador de
formularios y controles basados en diagramas), con código fuentes
extensivos proyectos de ejemplo demostrando las características
avanzadas - hasta se incluye básicamente un diseñador de reportes.
http://www.lmdinnovative.com/products/vcl/lmddesignpack/
Para la próxima edición, tenemos disponible el siguiente premio para
uno de los autores que colabore artículos en inglés:
* llPDFLib v1.1 - por llionsoft, Shareware ($70, $280 con fuentes)
llPDFLib en una biblioteca en puro Object Pascal para crear documentos
PDF. No usa ninguna DLL ni software externo de terceras partes para
generar ficheros PDF. La librería consiste del componente TPDFDocument
con propiedades y métodos como los del TPrinter de Delphi, pero
diseñado para generar un fichero PDF.
http://www.llion.net/
Si usan Delphi 6 ó 7, no se olviden de ver Actualizaciones de Delphi en
la sección Delphi en la Red de este boletín. A propósito, Borland está
realizando un par de encuestas, una para los usuarios de Delphi y otra
para los miembros de la Borland Development Network. Encontrarán los
enlaces bajo el título Otros Enlaces en la sección Delphi en la Red.
Espero que disfruten esta edición.
Saludos,
Ernesto De Spirito
eds2008 @ latiumsoftware.com
__________________
Colaboró en esta edición: Dave Murray
________________________________________________________________________
Greatis Runtime Fusion incluye Form Designer Pro ($ 49.95) y Object
Inspector Pro ($ 49.95), y cuesta sólo $89.90 - Ahórrese $10 y obtenga
demos adicionales. Permita que el usuario diseñe formularios en tiempo
de ejecución con Runtime Fusion. >>>> http://www.greatis.com/runtime.htm
________________________________________________________________________
2. Administrador de depuración avanzado (manejador de excepciones)
Como implementar una clase Debug que muestre el nombre de la unidad,
el nombre de la función y el número de línea de una excepción
Por Olivier Rogier <software @ urimont.com>
Software Engineering - Ingénierie Logicielle
http://www.urimont.com
Lea el archivo file_id.diz en la carpeta XAM del archivo zip adjunto
para encontrar las instrucciones para instalar eXpress Application
Manager (XAM) para Delphi 5-7.
El requisito es instalar la generación detallada del archivo de mapa
en las opciones de enlace del proyecto (Project | Options | Linker |
Map file | Detailed).
DEBUG_MODE es una constante booleana que indica si el objeto Debug está
activado de manera predeterminada al iniciar. Puede ser modificada con
los comandos en línea de órdenes /debug y /nodebug.
TObjectInfos se usa para obtener información de la instancia de la
clase como nombre, padre(s), dueño(s). TMapFile se usa para obtener
información sobre la excepción: nombre de la unidad, nombre del proce-
dimiento y número de línea.
IDebug es una interfaz implementada por TDebug. La función GetDebug
devuelve un puntero a IDebug referenciando una instancia TDebug creada y
destruida en la secciones initialization y finalization de la unidad. El
usuario no puede destruirla o crear más instancias.
El usuario puede establecer los eventos Before y After y establecer el
estado de activación. ShowException se usa por el manejador de excep-
ciones interno y puede ser usado por el usuario.
Se puede implementar un bonito formulario de excepción y un archivo de
registro.
________________________________________________________________________
¿Cómo calificaría al boletín? ¡Califique al Boletín Pascal en el ranking
Top 200 Delphi! · http://top200.jazarsoft.com/delphi/rank.php3?id=latium
________________________________________________________________________
3. Interceptando mensajes de Windows en componentes no visuales
Como hacer que un componente sin ventana reciba mensajes de Windows
By Peter Johnson, Copyright (c) 2003
<delphidabbler @ contactbox.co.uk> - http://www.delphidabbler.com/
A veces necesitamos que un componente sin ventana (es decir, uno que no
derive de TWinControl) reciba mensajes de Windows - pero los componentes
sin ventana no tienen manejador ("handle") de ventana. Por ejemplo
suponga que está desarrollando un componente no visual que registre su
aplicación como un visor del portapapeles de modo que la aplicación
pueda responder a cambios en el portapapeles (si desea saber como hacer
eso vea el artículo http://www.delphi3000.com/articles/article_575.asp
que lo explica). Para obtener información acerca de los cambios en el
portapapeles nuestro componente necesita recibir mensajes de Windows.
La función AllocateHWnd de la librería de Delphi se usa para crear por
nosotros una ventana oculta, y la función relacionada DeallocateHWnd
libera la ventana cuando hayamos terminado con ella.
La ventana oculta necesita un procedimiento de ventana. Podemos usar un
método de nuestra clase componente para proveer un procedimiento de
ventana. AllocateHWnd toma una referencia al método como parámetro - y
se ocupa por nosotros de registrar el método como un procedimiento de
ventana. En el método manejamos los mensajes que nos interesan y le
dejamos el resto a Windows usando la llamada a la API DefWindowProc.
El siguiente código ofrece el esqueleto de como usar AllocateHWnd.
Primero, aquí está la declaración de la clase en la sección interface
del código:
type
// Nuestra clase derivada de TComponent
// (u otra clase ancestro)
TMyClass = class(TComponent)
private
FHWnd: HWND;
// campo para almacenar el manejador ("handle") de ventana
...
protected
procedure WndMethod(var Msg: TMessage); virtual;
// el procedimiento de ventana (window proc) - llamado por
// Windows para manejar mensajes
...
public
constructor Create(AOwner: TComponent); override;
// crear el manejador de ventana aquí
destructor Destroy; override;
// liberar el manejador de ventana aquí
...
end;
Y aquí están los detalles de implementación:
TMyClass.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
...
// Crea la ventana
FHWnd := AllocateHWnd(WndMethod);
...
end;
TMyClass.Destroy;
begin
...
// Destruye la ventana
DeallocateHWnd(FHWnd);
...
inherited Destroy;
end;
TMyClass.WndMethod(var Msg : TMessage);
var
Handled: Boolean;
begin
// Asumimos que manejamos el mensaje
Handled := True;
case Msg.Msg of
WM_ALGO: HacerAlgo;
// Código para manejar un mensaje
WM_OTRACOSA: HacerOtraCosa;
// Código para manejar otro mensaje
...
else
// No manejamos el mensaje
Handled := False;
end;
if Handled then
// Manejamos el mensaje - lo indicamos en el resultado del mesaje
Msg.Result := 0
else
// No manejamos el mensaje
// Se lo pasamos a DefWindowProc y registramos el resultado
Msg.Result := DefWindowProc(FHWnd, Msg.Msg,
Msg.WParam, Msg.LParam);
end;
Por supuesto, podríamos usar la API de Windows para crear una ventana de
la manera difícil, y proveer un procedimiento de ventana. Pero es más
difícil usar un método como procedimiento de ventana (en vez de un
simple procedimiento) si lo hacemos de esta manera. Las características
inteligentes de AllocateHWnd son que (a) crea la ventana oculta por
nosotros y (b) nos permite usar un método, en vez de un simple proce-
dimiento como el procedimiento de ventana -- y un método es más útil
puesto que tiene acceso a los datos privados de la clase.
Se adjunta a este artículo un componente visor del portapapeles
(cbview).
__________________
Peter Johnson es un programador hobbyista que vive en West Wales (Reino
Unido) y que "chapotea" en Delphi. Mantiene el sitio web DelphiDabbler
(http://www.delphidabbler.com/) donde publica sus artículos y sus
aplicaciones y componentes Delphi gratuitos.
________________________________________________________________________
¿Cuándo fue la última vez que votó por el Boletín Pascal? Por favor
apoye esta iniciativa votándonos en "The Programming Top 100!"
Sólo hay que seguir el enlace y hacer clic en "here" ("aquí") donde dice
"Click here to vote!" ("¡Haga clic aquí para votar!"). Luego aparecerá
el ranking de los más votados. Su voto significa mucho para nosotros.
________________________________________________________________________
4. Asocie su programa con extensiones de archivo
Como hacer asociaciones de archivo a sus ejecutables
Por Igor Siticov
SiComponents: http://www.sicomponents.com
¿Cómo puedo asociar mi extensión de archivo con mi aplicación?
Para crear asociaciones de archivo debe hacer algunos cambios en el
registro de Windows e informar al Explorador de Windows acerca de sus
cambios.
Para ejecutar su programa como predeterminado para todos los tipos de
archivo no registrados simplemente asócielo con el tipo de archivo "*".
La siguiente unidad incluye la realización de una función para crear
una asociación de archivo. Vea los comentarios en el código fuente para
más detalles.
unit utils;
interface
uses Registry, ShlObj, SysUtils, Windows;
procedure RegisterFileType(cMyExt, cMyFileType, cMyDescription,
ExeName: string; IcoIndex: integer; DoUpdate: boolean = false);
implementation
procedure RegisterFileType(cMyExt, cMyFileType, cMyDescription,
cExeName: string; IcoIndex: integer; DoUpdate: boolean = false);
var
Reg: TRegistry;
begin
Reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CLASSES_ROOT;
// 1) Asignar la extensión al tipo de archivo,
// creando la extensión si no existe
// Abre o crea la clave HKCR\<cMyExt>
Reg.OpenKey(cMyExt, True);
// HKCR\.<cMyExt>\(Predeterminado)="<cMyFileType>"
Reg.WriteString('', cMyFileType);
Reg.CloseKey;
// 2) Asignar la descripción del tipo de archivo,
// creando el tipo de archivo si no existe
// Abre o crea la clave HKCR\<cMyFileType>
Reg.OpenKey(cMyFileType, True);
// HKCR\<cMyFileType>\(Predeterminado)="<cMyDescription>"
// Esto es lo que se verá en la descipción del tipo de archivo
// en las propiedades de los archivos de ese tipo.
Reg.WriteString('', cMyDescription);
Reg.CloseKey;
// 3) Asignar el índice del icono para el tipo de archivo,
// creando la clave correspondiente si no existiera
// Abre o crea la clave HKCR\<cMyFileType>\DefaultIcon
Reg.OpenKey(cMyFileType + '\DefaultIcon', True);
// HKCR\<cMyFileType>\DefaultIcon\(Predeterminado)
// ="<cExeName>,<IcoIndex>"
Reg.WriteString('', cExeName + ',' + IntToStr(IcoIndex));
Reg.CloseKey;
// 4) Establece el texto de la acción Open (abrir) en el
// Explorador, creando la acción si no existiera
// Abre o crea la clave HKCR\<cMyFileType>\Shell\Open
Reg.OpenKey(cMyFileType + '\Shell\Open', True);
// HKCR\<cMyFileType>\Shell\Open\(Predeterminado)="&Abrir"
Reg.WriteString('', '&Abrir');
Reg.CloseKey;
// 5) Asigna la aplicación con la que ejecutar la acción
// Abre o crea la clave HKCR\<cMyFileType>\Shell\Open\Command
Reg.OpenKey(cMyFileType + '\Shell\Open\Command', True);
// HKCR\<cMyFileType>\Shell\Open\Command\
// (Predeterminado)=""<cExeName>" "%1""
// Su aplicación debe revisar el parámetro en la línea de
// comandos para saber que archivo se le pasó.
Reg.WriteString('', '"' + cExeName + '" "%1"');
Reg.CloseKey;
// 6) Finalmente, si queremos que el Explorador de Windows se de
// cuenta que agregamos nuestro tipo de archivo, llamamos a la
// API SHChangeNotify.
if DoUpdate then
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, nil, nil);
finally
Reg.Free;
end;
end;
end.
Llamada de ejemplo:
RegisterFileType('.abc', 'abc_type', 'Archivo ABC',
'U:\Camino\Programa.exe', 0, True);
__________________
Igor Siticov es el autor de TsiLang Components Suite (un completo juego
de componentes para construir en dos minutos aplicaciones multilingües
elegantes, útiles y amistosas con el usuario) y de Resource Builder (un
muy completo editor visual de RC script, ideal para reemplazar al
Borland Image Editor y al Borland Resource WorkShop para crear y editar
archivos de recursos), por SiComponents: http://www.sicomponents.com
________________________________________________________________________
Difunda el Boletín Pascal entre sus colegas programadores invitándolos a
visitar nuestra página http://www.latiumsoftware.com/es/pascal/index.php
o a que se suscriban por email: boletin-pascal-subscribe@gruposyahoo.com
________________________________________________________________________
5. Inline Assembler en Delphi (VII) - Aritmética entera de 128 bits (1)
Por Ernesto De Spirito
Introducción
============
Con 32 bits podemos representar 2^32 números diferentes, es decir,
4294967296 (~4 mil millones, o ~4 millardos) de números diferentes, como
enteros con signo de -2147483648 a +2147483647 o enteros sin signo del 0
al 4294967295 (tipos Longint y Longword respectivamente).
Eso es suficiente para muchos propósitos, como por ejemplo representar la
posición de un byte en un archivo de 4GB, pero algunas veces necesitamos
más, y allí tenemos TLargeInteger (unidad Windows) e Int64 (desde Delphi
4) para representar enteros de 64 bits que pueden tener 2^64 valores
diferentes, es decir, 18446744073709551616 (~18 trillones de) valores,
que van de -9223372036854775808 a +9223372036854775807 (~9 trillones).
Esa cantidad de dígitos es más que suficiente para mí, y en este
instante la verdad que no puedo imaginarme ningún uso práctico para más
de eso. ¡Hey, ni siquiera Bill Gates cuenta su dinero en trillones! ;)
Pero de tanto en tanto veo alguien en algún foro preguntando por más
dígitos de los que ofrece Int64...
De todos modos, ya sea útil para un propósito práctico o completamente
inútil, veremos la implementación de muchos procedimientos y funciones
diseñandos para trabajar con enteros de 128 bits, que servirán para el
propósito de mostrar ejemplos de instrucciones básicas de ensamblador.
Estos "enteros grandes", "enteros enormes" o "enteros gigantes" pueden
contener 2^128 valores diferentes, es decir, 38-39 dígitos decimales
significativos.
Representación de un entero de 128 bits
=======================================
He llamado al nuevo tipo Hugeint (por "huge integer" = "entero enorme"
o "entero gigante"), pero por ejemplo Bigint ("big integer" = "entero
grande"), o Int128 también son buenos nombres.
En lo que respecta a la representación del nuevo tipo, también hay
muchas formas de hacerlo. Decidí que lo más simple es representarlo como
un arreglo de 4 enteros de 32 bits:
type
Hugeint: packed array [0..3] of Longword;
Usaremos el formato "little-endian" puesto que es el estándar en la
arquitectura Intel. Esto significa que el primer elemento del arreglo
(dirección más baja) contendrá los 32 bits de orden bajo (menos
significativos) del entero gigante, mientras que el último elemento
(dirección más alta) del arreglo contendrá los 32 bits de orden alto
(más significativos) del entero gigante.
Así es como serían representados los números 5 y 5000000000
($12A05F200):
+---- 32 bits de orden bajo (menos significativos)
|
v
+-------------+-------------+-------------+-------------+
| $00000005 | $00000000 | $00000000 | $00000000 | = 5
+-------------+-------------+-------------+-------------+
0 1 2 3
+-------------+-------------+-------------+-------------+
| $2A05F200 | $00000001 | $00000000 | $00000000 | = 5000000000
+-------------+-------------+-------------+-------------+ $12A05F200
^
|
32 bits de orden alto (más significativos) ----+
Los enteros en sí mismos también se almacenan en formato little-endian.
La representación de bytes de los números en un volcado de memoria se
verá como se muestra a continuación (los valores de los bytes se
representan en notación hexadecimal):
$00000005
+-------------+-------------+-------------+-------------+
| 05 00 00 00 | 00 00 00 00 | 00 00 00 00 | 00 00 00 00 | = 5
+-------------+-------------+-------------+-------------+
0 1 2 3
+-------------+-------------+-------------+-------------+
| 00 F2 05 2A | 01 00 00 00 | 00 00 00 00 | 00 00 00 00 | = 5000000000
+-------------+-------------+-------------+-------------+ $12A05F200
$2A05F200 $00000001
Sin embargo, para casi todas las operaciones podemos hacer abstracción
del orden de los bytes y considerar los enteros de 32 bits como unidades
atómicas, pues el orden de los bytes se maneja transparentemente.
Algunas instrucciones útiles
============================
Antes de comenzar, veamos algunas instrucciones útiles que posiblemente
usemos en este artículo (sobre todo en la continuación de esta primera
parte), pero primero permítanme decirles que el propósito de este
artículo no es enseñarles ensamblador. Todo lo que puedo hacer en este
espacio limitado es mostrarles ejemplos de algunas instrucciones. Por
material de referencia, les recomiendo estos enlaces:
* Intel 80386 Reference Programmer's Manual
Una versión HTML de este manual de Intel. El pseudo-código ayuda a
explicar las instrucciones y sus efectos en las señales. Excelente.
http://people.freebsd.org/~jhb/386htm/toc.htm
Hay algunos enlaces rotos, pero las páginas están allí. Intenten
desde el índice del directorio si tienen algún problema:
http://people.freebsd.org/~jhb/386htm/
* iAPx86 - Norton Guide
No tan explicativo como el documento de arriba, pero contiene todas
las instrucciones desde el 8086 hasta el Pentium y Pentium Pro, con
información sobre tamaño y tiempo de ejecución que no se incluye en
el documento de arriba.
http://www.clipx.net/ng/iapx86/index.php
* The IA-32 Intel Architecture Software Developer's Manual, Volume 2:
Instruction Set Reference
Manual PDF describiendo las instructiones para los procesadores IA-32
(Pentium, Pentium Pro, Pentium II, Pentium III, Pentium 4, y Xeon).
Incluye pseudo-código para explicar las instrucciones y sus efectos en
las señales (flags) del registro de señales (flags register).
http://www.intel.com/design/pentium4/manuals/245471.htm
* Optimización
- How to optimize for the Pentium family of microprocessors
Excelente guía de optimización escrita por Agner Fog
http://fatphil.org/x86/pentopt/index.html
- Optimizations for Intel's 32-Bit Processors
Otra excelente guía de optimización, pero en formato PDF.
http://x86.ddj.com/ftp/manuals/686/optimgd.pdf
Muy bien, ahora vayamos a las instrucciones.
Referencia:
Z/ZF: Zero Flag (señal de cero)
S/SF: Sign Flag (señal de signo)
C/CF: Carry Flag (señal de acarreo)
P/PF: Parity Flag (señal de paridad)
A/AF: Auxiliary Flag (señal de acarreo auxiliar)
O/OF: Overflow Flag (señal de sobreflujo)
s: bit de sign (bit de orden alto)
o: bit de imparidad (bit de orden bajo)
x: valor del bit
0: literalmente, el valor 0
1: literalmente, el valor 1
r: el bit está invertido respecto del valor previo
u: el bit conserva su valor
XX: valor desconocido (registro, inmediato, o referencia a memoria)
En los ejemplos se debe asumir que el valor de AL previo a cada
operación es sxxxxxxo (bit de signo, 6 bits desconocidos, y bit de
imparidad).
Aquí hay algunas instrucciones para comenzar:
SHL al,1 AL := xxxxxxo0 CF := s SHift Left
SAL al,1 AL := xxxxxxo0 CF := s Sinónimo de SHL
SHR al,1 AL := 0sxxxxxx CF := o SHift Right
SAR al,1 AL := ssxxxxxx CF := o Shift Arithmetic Right
SAR al,7 AL := ssssssss CF := x Esto extiende el bit de signo
ROL al,1 AL := xxxxxxos CF := s ROtate Left
ROR al,1 AL := osxxxxxx CF := o ROtate Right
RCL al,1 AL := xxxxxxoC CF := s ROtate thru Carry Left
RCR al,1 AL := Csxxxxxx CF := o ROtate thru Carry Right
AND al,al AL := uuuuuuuu CF := 0 Establece señales (ver abajo)
AND al,-1 AL := uuuuuuuu CF := 0 -1 = $FF = 1111111
Establece señales (ver abajo)
AND al,$01 AL := 0000000u CF := 0 $01 = 00000001
AND al,$80 AL := u0000000 CF := 0 $80 = 10000000
AND al,$5A AL := 0u0uu0u0 CF := 0 $5A = 01011010
AND al,0 AL := 00000000 CF := 0 XOR AL,AL o MOV AL,0 es mejor
TEST AL,XX AL := uuuuuuuu
TEST es como AND, pero el resultado no se almacena en el
destino, sino que se usa para establecer flags (ver abajo)
TEST AL,-1 Habitualmente es mejor que AND AL,-1 y que OR AL,AL porque
no escribe en AL, lo que permite ciertas optimizaciones en
algunos casos.
OR al,al AL := uuuuuuuu CF := 0 Establece señales (ver abajo)
OR al,$01 AL := uuuuuuu1 CF := 0 $01 = 00000001
OR al,$80 AL := 1uuuuuuu CF := 0 $80 = 10000000
OR al,$5A AL := u1u11u1u CF := 0 $5A = 01011010
OR al,-1 AL := 11111111 CF := 0 Igual que MOV AL,1
XOR al,al AL := 0 CF := 0 MOV AL,0 preserva las señales
XOR al,$5A AL := ururruru CF := 0 $5A = 01011010
XOR al,-1 AL := rrrrrrrr CF := 0 Igual que NOT AL
Excepto por las instrucciones de rotación (ROL, RCL, ROR, y RCR), todas
las de arriba establecen las señales SF, ZF y PF en base al resultado de
la operación:
SF = valor del bit de orden alto del resultado (bit de signo)
ZF = 1 ("establecida") si el resultado es cero, 0 ("limpia") en caso
contrario
PF = 1 ("encendida") si el byte de orden bajo del resultado contiene
un número par de bits 1, en caso contrario es 0 ("limpia")
Veamos más instrucciones:
STC CF := 1 SeT Carry flag
CLC CF := 0 CLear Carry flag
CMC CF := r CoMplement Carry flag
LAHF AH := SZxAxPxC
SAHF Asumiendo que AH es SZxAxPxC:
ZF := S; ZF := Z; AF := A; PF := P; CF := C
SETc AL AL := CF SET if Carry
SETs AL AL := SF SET if Sign
SETz AL AL := ZF SET if Zero
SETe AL AL := ZF SET if Equal (sinónimo de SETZ)
SETp AL AL := PF SET if Parity
SETpe AL AL := PF SET if Parity Even (sinónimo de SETP)
SETo AL AL := OF SET if Overflow
SETnc AL AL := NOT CF SET if Not Carry
SETns AL AL := NOT SF SET if Not Sign
SETnz AL AL := NOT ZF SET if Not Zero
SETne AL AL := NOT ZF SET if Not Equal (sinónimo de SETNZ)
SETnp AL AL := NOT PF SET if Not Parity
SETpo AL AL := NOT PF SET if Parity Odd (sinónimo de SETNP)
SETno AL AL := NOT OF SET if Not Overflow
SETa (o SETNbe), SETae (o SETnb), SETb (o SETnae), SETbe (o SETna),
SETg (o SETNle), SETge (o SETnl), SETl (o SETnge), y SETle (o SETng)
establecen el byte destino en 1 o 0 dependiendo de si la condición
especificada se cumple o no.
ADD AL,XX AL := AL+XX CF := 1 si la operación generó un acarreo
0 en caso contrario
SUB AL,XX AL := AL-XX CF := 1 si la operación requirió un bit
prestado, 0 en caso contrario
SUB AL,0 AL := uuuuuuuu Establece señales en base a AL
SUB AL,AL AL := 0 Igual que XOR AL,AL o MOV AL,0
CMP AL,XX CMP es como SUB, pero el resultado no se almacena en el
destino. La operación simplemente establece señales.
ADC AL,XX AL := AL+XX+C CF := 1 si la operación generó un acarreo
0 en caso contrario
SBB AL,XX AL := AL-C-XX CF := 1 1 si la operación requirió un bit
prestado, 0 en caso contrario
NEG AL AL := -AL CF := 1 si el valor previo de AL es <> 0
NOT AL; INC AL es lo mismo
NOT AL AL := rrrrrrrr CF := u Igual que XOR AL,-1
Funciones de conversión
=======================
Estas funciones nos ayduarán a entender la representación de estos
enteros enormes.
Longword a Hugeint
------------------
Comencemos convirtiendo un Longword en un entero gigante. Los 32 bits
más bajos del resultado serán los 32 bits del parámetro, y los 96 bits
más altos serán todos cero.
function UToHugeint(const x: Longword): Hugeint; overload;
// Result := Hugeint(x);
// Parámetros: EAX = x; EDX = @Result;
asm
xor ecx, ecx // ECX := 0;
mov [edx+_0_], eax // Result[0] := x;
mov [edx+_1_], ecx // Result[1] := 0;
mov [edx+_2_], ecx // Result[2] := 0;
mov [edx+_3_], ecx // Result[3] := 0;
end;
Comentarios:
* ¿"_0_", "_1_", "_2_" y "_3_"? ¿Qué son?
Son constantes que representan los desplazamientos (en bytes) de los
cuatro elementos del arreglo, las que nos permiten escribir código más
limpio.
const
_0_ = 0;
_1_ = 4;
_2_ = 8;
_3_ = 12;
Longint a Hugeint
----------------
Los 32 bits más bajos del resultado serán los 32 bits del parámetro. Si
el número es positivo, entonces los 96 bits más altos serán 0, pero si
el número es negativo, los 96 bits más altos serán 1.
Puede parecer que necesitamos realizar una comparación o comprobar el
signo y luego realizar un salto condicional basado en el resultado:
function IntToHugeint(x: Longint): Hugeint; overload;
// Convierte un entero con signo de 32 bits a Hugeint
// Parámetros: EAX = x; EDX = @Result;
asm
or eax, eax // EAX := EAX or EAX; // EAX permanece igual
// Efecto secundario: SF (Sign Flag) := EAX < 0;
mov ecx, 0 // ECX := 0;
jns @@no_negativo // if not SF then goto @@no_negativo;
dec ecx // ECX := ECX - 1; // 0 - 1 = -1 = $FFFFFFFF
@@no_negativo:
mov [edx+_0_], eax // Result[0] := x;
mov [edx+_1_], ecx // Result[1] := ECX; // 0 o $FFFFFFFF
mov [edx+_2_], ecx // Result[2] := ECX; // 0 o $FFFFFFFF
mov [edx+_3_], ecx // Result[3] := ECX; // 0 o $FFFFFFFF
end;
Comentarios:
* Nótese el uso de "MOV ECX, 0" en vez de "XOR ECX, ECX" para evitar
cambiar el estado de la señal de signo (Sign Flag - SF) establecida en
la instrucción precedente (OR) y luego usada en el salto condicional
que aparece en la instrucción siguiente (JNS). Por supuesto que
pudimos haber cambiado el orden de las operaciones para que esto no
sea necesario...
* En vez de:
or eax, eax
jns @@no_negativo
los siguientes pares de instrucciones hubieran logrado lo mismo:
* and eax, eax // EAX inalterado, pero SF obtiene el signo
jns @@not_negative // if SF = 0 then goto @@not_negative
* test eax, eax // EAX inalterado, pero SF obtiene el signo
// Es mejor porque no se escribe en EAX
jns @@not_negative // if SF = 0 then goto @@not_negative
* test eax, $87654321 // Cualquier valor con el bit 31 (signo) = 1
jns @@not_negative // if SF = 0 then goto @@not_negative
* test eax, $80000000 // el resultado será 0 y la señal de cero (Zero
// Flag - ZF) será encendida si el bit de signo
// (el más significativo) es cero (eax >= 0).
jz @@no_negativo // if Zero Flag then goto @@no_negativo
* cmp eax, 0 // compara EAX con 0
jge @@not_negative // if mayor o igual then goto @@not_negative
* Nótese el uso de "DEC ECX" para tornar el valor de ECX de $00000000 a
$FFFFFFFF (decrementanto el valor del registro). "NOT ECX" habría
logrado lo mismo (invirtiendo los bits), con la misma velocidad, y
tomando la misma cantidad de bytes para codificar la instrucción, pero
NOT no es una instrucción emparejable mientras que DEC sí lo es. Por
esta razón habitualmente se evita NOT y se sustituye como sigue:
- Si sabe de antemano que el valor previo es 0, use DEC Destino
- Si sabe de antemano que el valor previo es 1, use INC Destino
- Si no sabe de antemano cual es el valor previo, use XOR Destino, -1
* También noten en el orden de las instrucciones que nunca usamos un
registro que fuera escrito en la instrucción previa. Esta es una de
las condiciones para que ocurra el emparejamiento. Encontrarán más
información acerca del emparejamiento de instrucciones en los
documentos sobre optimización que recomendamos arriba.
Pordemos simplificar la función gracias a la instrucción CDQ que
extiende el signo de EAX en EDX. Así es básicamente como trabaja CDQ:
if EAX >= 0 then
EDX := $0
else
EDX := $FFFFFFFF;
He aquí una implementación más pequeña y simple usando CDQ:
function ToHugeint(const x: Longint): Hugeint; overload;
// Result := Hugeint(x);
// Parámetros: EAX = x; EDX = @Result;
asm
mov ecx, edx // ECX := @Result;
cdq // EDX := IIF(x>=0, 0, $FFFFFFFF);
mov [ecx+_0_], eax // Result[0] := x;
mov [ecx+_1_], edx // Result[1] := EDX; // 0 o $FFFFFFFF
mov [ecx+_2_], edx // Result[2] := EDX; // 0 o $FFFFFFFF
mov [ecx+_3_], edx // Result[3] := EDX; // 0 o $FFFFFFFF
end;
CDQ habitualmente se reemplaza por MOV y SAR, que ofrecen la ventaja
que el origen no tiene que ser EAX y que el destino tampoco tiene que
ser EDX, además que son instrucciones emparejables. Veamos un ejemplo:
function ToHugeint(const x: Longint): Hugeint; overload;
// Result := Hugeint(x);
// Parámetros: EAX = x; EDX = @Result;
asm
mov ecx, eax // ECX := x;
sar ecx, 31 // ECX := IIF(x>=0, 0, $FFFFFFFF);
mov [edx+_0_], eax // Result[0] := x;
mov [edx+_1_], ecx // Result[1] := EDX; // 0 o $FFFFFFFF
mov [edx+_2_], ecx // Result[2] := EDX; // 0 o $FFFFFFFF
mov [edx+_3_], ecx // Result[3] := EDX; // 0 o $FFFFFFFF
end;
Hugeint a Longint
-----------------
Un Hugeint puede ser convertido a Longint simplemente tomando los 32 bits
más bajos. Los 96 bits más altos del Hugeint deberían ser todos 0 o todos
1 coincidiendo con el bit 31 (bit de signo de lo que sería el resultado)
para que el valor del Hugeint esté en el rango de un Longint, pero la
función no comprueba esto y realiza la conversión ciegamente (del mismo
modo que por ejemplo un Longint se convierte en un Shortint).
function ToLongint(const x: Hugeint): Longint; overload;
// Result := Longint(x);
// No se lanza una excepción si el valor está fuera de
// rango (se descartan los 96 bits más significativos).
// Parámetros: EAX = @x;
asm
mov eax, [eax+_0_] // Result := x[0];
end;
Int64 a Hugeint
---------------
Los parámetros Int64 se pasan en la pila, así que las funciones con un
parámetro Int64 automáticamente crearán un marco de pila (stack frame).
Los 64 bits más bajos del resultado serán los 64 bits del parámetro y
los 64 bits más altos del resultado extenderán el bit de signo del
entero más significativo que forma el valor int64.
{$IFDEF DELPHI4}
function ToHugeint(const x: Int64): Hugeint; overload;
// Result := Hugeint(x);
// Parámetros: x en la pila; EAX = @Result;
asm
mov edx, dword[x+_0_] // EDX := x[0];
mov ecx, dword[x+_1_] // ECX := x[1];
sar ecx, 31 // ECX := IIF(x[1]>=0, 0, $FFFFFFFF);
mov [eax+_0_], edx // Result[0] := x[0];
mov [eax+_1_], ecx // Result[1] := x[1];
mov [eax+_2_], ecx // Result[2] := ECX; // 0 o $FFFFFFFF
mov [eax+_3_], ecx // Result[3] := ECX; // 0 o $FFFFFFFF
end;
{$ENDIF}
Los valores Int64 se almacenan en formato little-endian, así que el
entero de orden bajo (menos significativo) está primero (en el
desplazamiento 0 a partir de la dirección base de la variable), mientras
que el entero de orden alto (más significativo) está después (en el
desplazamiento 4 a partir de la dirección base de la variable). En este
caso, la dirección base de la variable es EBP+8 (véase el primer
capítulo de esta serie de artículos), así que el primer elemento está en
EBP+8 (EBP+8+0) y el segundo elemento está en EBP+12 (EBP+8+4). Podría
haber usado EBP+8 y EBP+12 para direccionar los elementos, pero "x+_0_"
y "x+_1_" refieren esas direcciones más transparentemente. El especi-
ficador de tamaño "DWORD" es necesario puesto que el ensamblador toma
"x+_0_" y "x+_1_" como punteros a datos de 64 bits (ya que considera que
"x" es un puntero a datos de 64 bits) y no permite mover el valor
referenciado a un registro de 32 bits.
Hugeint a Int64
---------------
Un Hugeint puede ser convertido a Int64 simplemente tomando los 64 bits
más bajos. Los 64 bits más altos del Hugeint deberían ser todos 0 o
todos 1 coincidiendo con el bit 63 (bit de signo de lo que sería el
resultado) para que el valor del Hugeint esté en el rango de un Int64,
pero la función no comprueba esto y realiza la conversión ciegamente:
{$IFDEF DELPHI4}
function ToInt64(const x: Hugeint): Int64; overload;
// Result := Int64(x)
// No se lanza una excepción si el valor está fuera de
// rango (se descartan los 64 bits más significativos).
// Parámetros: EAX = @x;
asm
mov edx, [eax+_1_] // EDX := x[1];
mov eax, [eax+_0_] // EAX := x[0];
// Result = EDX:EAX = x[1]:x[0]
end;
{$ENDIF}
Comentario:
* Los valores de retorno Int64 deben colocarse en EDX (32 bits más
significativos) y EAX (32 bits menos significativos).
Eso es todo por ahora. En futuras ediciones veremos funciones para
realizar operaciones matemáticas y lógicas con estos enteros largos.
________________________________________________________________________
JfControls Lib. Multilenguaje. Multiapariencia. Skins. Privilegios. Más
de 40 componentes integrados y personalizables. Múltiples problemas de
programación resueltos. Administración centralizada de recursos. Para
Delphi 3-2006 y C++ Builder 3-6. http://www.jfactivesoft.com/spindex.htm
________________________________________________________________________
6. Foros / listas de correo
Recordamos a los suscriptores las direcciones de nuestros foros. Para
unirse a algún foro, lo más recomendable es hacerlo desde la web para
así tener acceso a todas las áreas del foro y la configuración de las
opciones de suscripción, pero también es posible suscribirse por email.
Para suscribirse desde la web es necesario poseer un ID de Yahoo! (si
no tienes el tuyo, puedes conseguirlo gratis registrándote como usuario
de Yahoo!).
* Delphi-abierto. Programación en Delphi (todos los niveles). Si estás
en la etapa de aprendizaje o si no te agradan los foros discriminados
por niveles, este foro es para ti.
http://espanol.groups.yahoo.com/group/delphi-abierto
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-abierto/join
delphi-abierto-subscribe@gruposyahoo.com
* Delphi-intermedio. Programación en Delphi (nivel intermedio). Si ya
sabes mucho de Delphi, pero todavía te falta un largo trecho para ser
un gurú (o no tanto), este foro es para ti.
http://espanol.groups.yahoo.com/group/delphi-intermedio
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-intermedio/join
delphi-intermedio-subscribe@gruposyahoo.com
* Delphi-avanzado. Programación en Delphi. Sólo para gurús.
http://espanol.groups.yahoo.com/group/delphi-avanzado
Suscripción:
http://espanol.groups.yahoo.com/group/delphi-avanzado/join
delphi-avanzado-subscribe@yahoogroups.com
* GrupoKylix. Programación en Kylix.
http://espanol.groups.yahoo.com/group/GrupoKylix
Suscripción:
http://espanol.groups.yahoo.com/group/GrupoKylix/join
GrupoKylix-subscribe@yahoogroups.com
* FreePascal-es. Programación en Free Pascal (freepascal.org).
http://espanol.groups.yahoo.com/group/freepascal-es
Suscripción:
http://espanol.groups.yahoo.com/group/freepascal-es/join
freepascal-es-subscribe@yahoogroups.com
* Desarrolladores-Software. Un lugar para tratar todos aquellos temas
relacionados con el desarrollo de software y su comercialización, y
para compartir experiencias en el ámbito laboral, profesional o
comercial con otros.
http://es.groups.yahoo.com/group/desarrolladores-software
Suscripción:
http://es.groups.yahoo.com/group/desarrolladores-software/join
desarrolladores-software-subscribe@yahoogroups.com
* Componentes. Un foro para buscar/recomendar componentes de software
(componentes VCL y CLX, objetos ActiveX, librerías DLL, etc.), así
como utilidades, tutoriales, información, etc.
http://espanol.groups.yahoo.com/group/componentes
Suscripción:
http://espanol.groups.yahoo.com/group/componentes/join
componentes-subscribe@yahoogroups.com
________________________________________________________________________
¿Errores Delphi? Capture y registre cada error mostrando unidad, clase,
método y número de línea. http://www.eurekalog.com/bannerclick.php?id=15
________________________________________________________________________
7. Delphi en la Red
Por Dave Murray <irongut @ vodafone.net>
Componentes, librerías y aplicaciones
=====================================
Shareware/Comercial
-------------------
* EurekaLog v4.0.4 - by Fabio Dell'Aria (Std $29, Pro $49, Ent $99)
EurekaLog gives your application (GUI, Console, Web, etc.) the ability
to catch every exception, generate a detailed log (with unit, class,
method and line #) and send it via email. Fully integrated into the
IDE, you only need a single rebuild to add EurekaLog to your apps.
Does not decrease performance and increases compiled file size by just
0.5% - 4%. Compatible with Delphi 3 - 7 and all Windows platforms.
http://www.eurekalog.com/bannerclick.php?id=15
Freeware
--------
* eXpress Application Manager (XAM) for Delphi (with source code).
Don't loose more time with error messages like "Access violation",
"Division by zero" or "List index out of bounds"! Find quickly the
line of code concerned with the advanced exception manager XAM for
Delphi 5, 6 and 7. The XAM Debugger will help you to improve your
test phase or your users bug reporting.
http://www.urimont.com/index.php?page=delphi&subpage=delphi_xam
* InterBase Performance Monitor 1.1 Released
InterBase Performance Monitor provides a user-friendly interface for
InterBase 7's performance monitoring and administration features. You
can easily watch and control who is using resources on your server.
http://community.borland.com/article/0,1410,29632,00.html
* Audio Components Suite v2.0 - Andrei Borovsky (source) (DELPHI/KYLIX)
Components designed to perform different sound-processing tasks. ACS
can play sound via the sound card, acquire audio data from different
sources such as soundcard, audio CD and so on. Can also read and store
audio data in several file formats (including Ogg Vorbis).
http://www.mtu-net.ru/aborovsky/
* IdCGIRunner v3.1 - by Serhiy Perevoznyk (with source)
Execute CGI scripts using Indy TidHTTPServer.
http://users.chello.be/ws36637/
* IdISAPIRunner v3.1 - by Serhiy Perevoznyk (with source)
Execute ISAPI modules using Indy TidHTTPServer.
http://users.chello.be/ws36637/
* Icarus - Uses List Analyzer for Delphi v1.4.1 - by Peganza
Helps Delphi and Borland Pascal developers remove unnecessary units in
uses lists. Can also tell which units can be moved from the interface
to the implementation uses list.
http://www.torry.net/tools/developers/other/ICARUS3FULL.ZIP
* BDEChecker v1.0 - by Nick Moon
Performs a number of tests on your machine to check various settings
that are known/believed to cause problems with Paradox data tables.
http://www.nixsoft.co.uk/bdechecker.html
* LinLocalize v1.0 - by Jens Kuhner (with source) (KYLIX)
Free translation-tool for multilingual Kylix applications. It extracts
the Kylix-resources (resource strings and forms) of elf-files and
writes the translated resources back.
http://linlocalize.sourceforge.net/
* TurboPower Visual PlanIt v1.03 - by TurboPower (with source)
A set of synchronized, data-aware components for adding time, task and
contact management capabilities to applications written in Delphi and
C++Builder. Get that Outlook look & feel without the hassle.
https://sourceforge.net/projects/tpvplanit/
* TurboPower Abbrevia v3.04 - by TurboPower (with source) (DELPHI/KYLIX)
A compression toolkit for Delphi, C++Builder and Kylix. It supports
PKZIP 4, Microsoft CAB, TAR and gzip formats and the creation of self-
extracting archives. It includes visual components that simplify the
manipulation of ZIP files.
https://sourceforge.net/projects/tpabbrevia/
Actualizaciones de Delphi
-------------------------
* Update: Bold for Delphi Architect
Registered users of purchased versions of Delphi 7 Architect can
download Bold for Delphi Architect R4.0-D7.
http://community.borland.com/article/0,1410,29798,00.html
* Update: IntraWeb and Rave for Delphi 7
Delphi 7 updates for AtoZed IntraWeb and Nevrona Rave Reports are now
available to download for registered users of purchased versions of
Delphi 7 Pro, Enterprise, and Architect.
http://community.borland.com/article/0,1410,29792,00.html
* Update: Delphi 6 Runtime Library Update 2
An update for Delphi 6 is now available to download for registered
users of purchased versions of Delphi 6.
http://community.borland.com/article/0,1410,29791,00.html
* Borland Product Companion CDs are online
Companion CD submissions are now available for download for:
C++Builder 6 Companion CD; Delphi 7 Companion CD, disk 1; Delphi 7
Companion CD, disk 2; InterBase 7 Companion CD; JBuilder 8 Companion
CD; Kylix 3 Companion CD.
http://community.borland.com/article/0,1410,29797,00.html
Artículos, trucos y consejos
============================
* Multi-threaded programming contest winners - by John Kaster
Winners have been selected for the multi-threaded programming contest.
http://community.borland.com/article/0,1410,29786,00.html
* Building a stand-alone Web service with Indy in Delphi 7: Part I
- by Serge Dosyukov and Mike Pham
Shows how to build a stand-alone Web service using Indy and Delphi 7.
http://community.borland.com/article/0,1410,29484,00.html
* Building a stand-alone Web service with Indy in Delphi 7: Part II
- by Serge Dosyukov and Mike Pham
Part 2 demonstrates one technique for creating a single web service
that contains more than one TSoapDataModule instance.
http://community.borland.com/article/0,1410,29542,00.html
* Known Causes of Corruption in InterBase Databases - by Craig Stuntz
InterBase is, in general, a very stable database server and corruption
is rare. When corruption does occur, then, it is important to
determine the cause of the corruption. This article describes
circumstances that can cause corruption.
http://community.borland.com/article/0,1410,29515,00.html
* Monitoring System Shell Changes - by Zarko Gajic
Wanna get notified when a file gets created, renamed or deleted on the
system? Need to know the exact folder and file name? Let's start
monitoring system shell changes!
http://delphi.about.com/library/weekly/aa030403a.htm
* "Essential .NET" is not for the faint-of-heart - by Barb Seewer
http://builder.com.com/article.jhtml?id=u00220030220swr01.htm
* Tips for documenting an XML DTD - by William T. Kelly
http://builder.com.com/article.jhtml?id=u00420030219WTK01.htm
* An Overview of the new XPointer Specification - by Edmond Woychowsky
What are the details about the XPointer XML proposal, and how does it
compare to XPath? Learn more about this new standard and check out
some examples on how to put it to use.
http://builder.com.com/article.jhtml?id=u00320030220woy01.htm
* How to get the Selected Objects in a TWebbrowser?
http://www.swissdelphicenter.ch/en/showcode.php?id=1190
* How to Get Rid Of the Annoying SQL Wait Cursor?
http://www.swissdelphicenter.ch/en/showcode.php?id=1305
* How to Explode a String?
http://www.swissdelphicenter.ch/en/showcode.php?id=1326
* How to flash the modal window title when user clicks the parent form?
http://www.swissdelphicenter.ch/en/showcode.php?id=1393
* How to search a TreeView Item through its Text property?
http://www.swissdelphicenter.ch/en/showcode.php?id=1414
* How to hook a function (in your own application)?
http://www.swissdelphicenter.ch/en/showcode.php?id=1422
* How to make deleting items in a TListView faster?
http://www.swissdelphicenter.ch/en/showcode.php?id=1479
* How to implement flickerless animation of a sprite moving across a
background image?
http://www.swissdelphicenter.ch/en/showcode.php?id=1491
* How to jump to a certain key in Regedit?
http://www.swissdelphicenter.ch/en/showcode.php?id=1542
* How to Draw a line without using the LineTo function?
http://www.swissdelphicenter.ch/en/showcode.php?id=1569
* How to show balloon tooltips in my Delphi program?
http://www.swissdelphicenter.ch/en/showcode.php?id=1587
* How to popup the system menu at a specified position?
http://www.swissdelphicenter.ch/en/showcode.php?id=1594
* How to get paths of the folders in 'My Computer'?
http://www.swissdelphicenter.ch/en/showcode.php?id=1598
* Get CPU Speed - by Amir Mosavian
http://www.delphi3000.com/articles/article_3552.asp
* FEEDBACK: D6+ADO+MS.SS => D6+ADO+Oracle - by Hans Pieters
The results of a migration D6+ADO+MS.SS => D6+ADO+Oracle.
http://www.delphi3000.com/articles/article_3553.asp
* Auto LiveUpdate - by Xiao Smile
Auto LiveUpdate your program from an FTP server.
http://www.delphi3000.com/articles/article_3556.asp
* OnOffBtn - by Pete Coe
How to make a custom On/Off button with default Glyphs.
http://www.delphi3000.com/articles/article_3557.asp
* Event Chain Mechanism II - by Alex Wijoyo
Attach and detach many event handlers to an event at runtime.
http://www.delphi3000.com/articles/article_3560.asp
* Extracting complete list of URL's from the web server - by Sergey S
This article describes how to extract a list of all web resources
(URL's) from a web server like http://www.borland.com using the Clever
Internet Suite components. It can be implemented with any other
internet library.
http://www.delphi3000.com/articles/article_3561.asp
* Using the Google web APIs with Delphi - by Herbert Poltnik
http://www.delphi3000.com/articles/article_3563.asp
* Writing MS SQL Server Extended Stored Procedures with Delphi
- by Berend de Boer
http://www.delphi3000.com/articles/article_3564.asp
* Using the Affinity Mask in multi-CPU environments - by Kim Sandell
When writing applications that are designated to run in multi-CPU
environments, it is very useful to be able to control which CPU's the
application executes on. By optimizing the CPU usage one can
dramatically increase the performance of the application.
http://www.delphi3000.com/articles/article_3565.asp
* Quick Sort - by Sébastien Charest
How to quick sort an array?
http://www.delphi3000.com/articles/article_3566.asp
* Convert numbers to words - by Abdulaziz Jasser
http://www.delphi3000.com/articles/article_3567.asp
* Using XML in Delphi applications: Part II - by Sergey Kucherov
Implementing XML Parser using Microsoft SAX interface.
http://www.delphi3000.com/articles/article_3571.asp
* OpenGL I: Hello World - by Eber Irigoyen
Base code for your OpenGL Delphi applications.
http://www.delphi3000.com/articles/article_3572.asp
* mIRC DLL basics - by Gareth Ablett
Basic design use and layout of a Delphi DLL for mIRC.
http://www.delphi3000.com/articles/article_3573.asp
* Sort Order of Internet Explorer Favorites - by Daaron Dwyer
You can easily get the list of favorites from the directory, but how
can you emulate the same sort order showing in Internet Explorer?
http://www.delphi3000.com/articles/article_3574.asp
* Shell Programming with Delphi - by Marcel van Brakel
Some tricks for using Delphi for shell programming on Windows.
http://www.delphi-jedi.org/Jedi%3AVOY_SHELLPROG%3A372530
* ColorMask Lab Report
The purpose of this project is to display only the selected bits of
a 24-bit color image. Any or all of the 24-bits of each pixel can be
masked for display.
http://www.efg2.com/Lab/Graphics/Colors/ColorMask/index.htm
* Active Directory programming - by Marcel van Brakel
Active Directory programming isn't as hard as you thought, this
article steps through what you need to do.
http://www.delphi-jedi.org/Jedi%3AVOY_ACTIVEDIR%3A372530
* .Net Architecture - by Jon Shemitz
Overview of the .Net architecture, presented at BorCon London, 2002.
midnightbeach.com/jon/pubs/2002/BorCon.London/dotNetArchitecture.html
* PNG Graphics with Delphi and Kylix - by Chris Rorden
http://www.psychology.nottingham.ac.uk/staff/cr1/png.html
* 3D Controls - by Chris Rorden
This article is about controls that you can provide to allow a user to
select a viewpoint for a 3D image. It includes source code that
demonstrates the Euler Angles, Vector and Roll and ArcBall controls.
http://www.psychology.nottingham.ac.uk/staff/cr1/3d.html
* Scientific Mathematics - by Chris Rorden
Explains the use and benefits of 'Single Instruction, Multiple Data'
(SIMD) commands, ie. SSE, SSE2 and 3DNow!. Includes a Delphi app that
measures the time to complete a large number of maths operations using
either standard or SIMD commands.
http://www.psychology.nottingham.ac.uk/staff/cr1/simd.html
Kylix, CLX y Linux
------------------
* Kylix Deployment Notes for "Hello World" - by efg
Just how hard can it be to deploy a simple CLX application in Linux?
http://www.efg2.com/Lab/Library/Kylix/deployment.htm
* PNG Graphics with Delphi and Kylix - by Chris Rorden
http://www.psychology.nottingham.ac.uk/staff/cr1/png.html
* Graphics with Kylix - by Chris Rorden
http://www.psychology.nottingham.ac.uk/staff/cr1/kylix.html
* CLX and Cursors - by Matthias Thoma
CLX supports Bitmaps and Icons, as files and as resources, but misses
support for cursors. This article will fill that gap and show how to
create QCursors and how to load and use windows cursor resources.
http://www.efg2.com/Lab/Library/Kylix/MatthiasThoma/wincur.html
* KDE System Tray Applets - by Matthias Thoma
An easy way to add common TForms to KDEs system tray area.
http://www.efg2.com/Lab/Library/Kylix/MatthiasThoma/KDESystemTray.html
* Kylix for Delphi programmers - by Jon Shemitz
Presented at BorCon London, October 2002.
http://www.midnightbeach.com/jon/pubs/2002/BorCon.London/
KylixForDelphiProgrammers.html
Tutoriales
==========
* Speech Synthesis & Speech Recognition: Overview - by Brian Long
Overview of adding speech synthesis and speech recognition
capabilities into Delphi applications using the Microsoft Speech API.
http://community.borland.com/article/0,1410,29580,00.html
* Using SAPI 4 High Level Interfaces - by Brian Long
Details of adding speech synthesis and speech recognition capabilities
into Delphi applications using the high-level programming interfaces
in Microsoft Speech API v4.0 (SAPI 4).
http://community.borland.com/article/0,1410,29581,00.html
* Using SAPI 4 Low Level Interfaces - by Brian Long
Details of adding speech synthesis and speech recognition capabilities
into Delphi applications using the low-level programming interfaces
in Microsoft Speech API v4.0 (SAPI 4).
http://community.borland.com/article/0,1410,29582,00.html
* Speech Synthesis & Speech Recognition: Using SAPI 5.1
Details of adding speech synthesis and speech recognition capabilities
into Delphi apps using the Microsoft Speech API v5.1 (SAPI 5.1).
http://community.borland.com/article/0,1410,29583,00.html
* Windows NT Privileges - by Marcel van Brakel
This article describes how to discover and set Windows NT privileges
from your applications, so you can make better use Windows built-in
security capabilities.
http://www.thedelphimagazine.com/Samples/1577/1577.htm
* Creating an Internet Explorer-style User Interface Part 2
In the February 2003 issue of Hardcore Delphi, Fabio Lucarelli began
demonstrating how to build and maintain a user interface that mimics
the one in Internet Explorer and Outlook. In this article he continues
that task by introducing toolbar customization and chevrons, by using
two common controls: the toolbar and the Coolbar control.
pinnaclepublishing.com/dd/DDMag.nsf/0/BFBE071686BC1F6A85256CD9007AD663
* NTFS Disk Quotas - by Marcel van Brakel
Describes how to set and manage NTFS disk quotas programmatically.
http://www.thedelphimagazine.com/samples/1488/1488.htm
* File Sharing On Linux - by Primoz Gabrijelcic
Explores file locking support on Linux and presents a cross-platform
scheme for using the file system for interprocess synchronisation.
http://www.thedelphimagazine.com/samples/1481/1481.htm
* Interfaces: Off The Beaten Track - by Malcolm Groves
Shows how to use interfaces to automatically destroy objects, restore
objects to previous states, cut away swathes of try..finally blocks,
and deal with memory leaks.
http://www.thedelphimagazine.com/samples/1415/1415.htm
* Introduction to Design Patterns - by Ader Gonzalez
Introduces the concept of Design Patterns through the eyes of a Delphi
programmer.
http://www.delphi-jedi.org/Jedi%3AVOYPATTERNS
* Delphi: Type Safe Programming - by Richard A. Morris
A Run-Time Type Information tutorial from the 10th Borland Developer's
Conference. Includes a component called the RTTI Explorer which allows
us to delve into the innards of Delphi classes.
http://www8.pair.com/rmorris/rtti.htm
* Upcoming Borland WebEx events - by Anders Ohlsson
Feeling lazy today? Want to sit down in your pajamas and learn about
the technical details of software development utilizing some of the
finest technologies available today? Register for these seminars and
participate from the comfort of your own home to learn about: Delphi
for .NET, IntraWeb in Delphi, WebServices in Delphi and more.
Presented by Alain "Lino" Tadros.
http://community.borland.com/article/0,1410,29784,00.html
Otros enlaces
=============
* Borland Delphi Developer Survey 2003 - by John Kaster
Let Borland know what you would like to see in future Delphi releases
by taking this survey. Five winners will receive a free Borland RAD
Enterprise/Architect software product of their choice.
http://community.borland.com/article/0,1410,29822,00.html
* 2003 Borland Developer Network (BDN) Survey - by David I
Help make sure that Borland continues to provide products, services
and support that you count on. Complete this comprehensive survey to
help Borland better understand your priorities and better serve your
needs going forward. As a small "thank you" for participation, you'll
be entered in a drawing for copies of Borland products - each valued
at up to $4000.
http://whatever.borland.com/bdnsurvey.html
* Public beta: Quality Central browser client
The public beta of the browser interface to QualityCentral (QC) is now
live. This beta of the web client (WC) is focused on functionality,
browser compatibility, and ease of use.
http://community.borland.com/article/0,1410,29803,00.html
* The FirebirdSQL Foundation
We are very pleased to announce the formation of "The FirebirdSQL
Foundation", a non-profit association with the objectives of
supporting and advancing the development of the open source
FirebirdSQL relational database engine.
http://www.swissdelphicenter.ch/en/shownews.php?id=349
Noticias
========
* Blog with Delphi and Borland news
http://svd.blogspot.com/
* Delphi / InterBase WebLog - by Craig Stuntz
News of interest to Delphi and InterBase developers.
http://delphi.weblogs.com/
* 28-FEB-2003: Update: Bold for Delphi Architect - by John Kaster
An update to Bold for Delphi 7 Architect is now available.
http://bdn.borland.com/article/0,1410,29798,00.html
* 01-MAR-2003: Borland Fires "Sidewinder" at VS.NET - by Alan Zeichick
Forthcoming C# IDE for Windows to support models, non-Microsoft
databases. Bringing together its compiler and IDE expertise, newly
acquired modeling software from TogetherSoft, and the .NET Framework
SDK licensed from Microsoft Corp., Borland Software Corp. is preparing
to release its own C# IDE for .NET.
http://www.sdtimes.com/news/073/story4.htm
* 01-MAR-2003: Borland Pulls Together
Talk about hitting the ground running. Borland Software Corp. has
already revamped its developer tools to incorporate key technologies
from its TogetherSoft acquisition–and the deal closed only one month
ago.
http://www.sdtimes.com/opinions/opinion_073.htm
* Borland Delphi .NET - Scheduled for April 2003
Borland's .NET tools lag behind Microsoft's, but the prospect of
cross-platform integration and strong modelling features should
ensure a significant share of the .NET market.
http://www.pcpro.co.uk/?reviews/reviews_story.php?id=38828
________________________________________________________________________
¡Vote por el Boletín Pascal en The Programming Pages!
http://www.programmingpages.com/?r=latiumsoftwarecomenpascal
________________________________________________________________________
¡Tú puedes ayudarnos!
Por favor danos una mano y ayúdanos a llegar a los 10.000 suscriptores
en los próximos meses. Una forma en que puedes ayudarnos es enviando
este enlace a tus amigos:
http://www.latiumsoftware.com/es/pascal/index.php
boletin-pascal-subscribe@gruposyahoo.com
Otra forma es votándonos en alguno de estos rankings para darle más
visibilidad a nuestro sitio web y aumentar así el número de suscrip-
ciones al boletín:
http://www.programmingpages.com/?r=latiumsoftwarecomenpascal
http://top100borland.com/in.php?who=20
http://www.lawebdelprogramador.com/buscar/votar.php?id=615
Por favor vota. Son sólo unos segundos para ti que REALMENTE pueden
hacer la diferencia. Necesitamos tu ayuda para poder continuar.
________________________________________________________________________
Si no has recibido el archivo con el código fuente completo de los
ejemplos que se presentan en este boletín, puedes descargarlo de la
siguiente dirección: http://www.latiumsoftware.com/es/file.php?id=p45
________________________________________________________________________
Página principal: http://www.latiumsoftware.com/es/pascal/index.php
Página del grupo: http://espanol.groups.yahoo.com/group/boletin-pascal/
Para suscribirse / apuntarse: boletin-pascal-subscribe@gruposyahoo.com
Para cancelar / removerse: boletin-pascal-unsubscribe@gruposyahoo.com
Para reportar problemas con la suscripción: eds2008 @ latiumsoftware.com
________________________________________________________________________
Este boletín se provee "TAL Y COMO ESTA", sin garantía de ninguna clase.
Su uso implica la aceptación de nuestros términos de licencia y de la
ausencia de garantía que puedes leer en nuestro sitio web. Allí también
encontrarás una nota sobre marcas registradas. Te animamos a que redis-
tribuyas este boletín, siempre y cuando lo hagas en forma completa
(incluyendo la información de copyright), sin modificaciones y de manera
gratuita. Los artículos son copyright de sus respectivos autores y se
reproducen aquí con el permiso de los mismos.
________________________________________________________________________
Latium Software http://www.latiumsoftware.com/es/index.php
Copyright (c) 2003 por Ernesto De Spirito. Todos los derechos reservados
________________________________________________________________________
|
