The curse of Dennis D. Spreen » Delphi 2009

VerySimpleXML – a lightweight Delphi XML reader and writer

Dennis — Thu, 10 Nov 2011 10:04:24 +0000

There are lot of possibilities if you’re in need to parse or write XML files:

use TXMLDocument (the MSXML wrapper)
or use xml components like OmniXML, NativeXml, ADOM, SAX, libxml2, DIXml, fcl-XML, Fast XMLParser, SimpleXML

Now here comes another one: VerySimpleXML – a lightweight, one-unit XML reader/writer in under ~~500~~ 600 lines of code. Use it for small well-formed XML files (like configuration files, etc.).

Download verysimplexml-v1.1.zip (7kb)
Download verysimplexml-v1.0.zip (7kb)

What’s new:
v1.1 – 2012/05/01
changed class name to reflect unit naming (class is now called
TXmlVerySimple instead TVerySimpleXml)
- it uses TStreamReader to read line by line instead of reading the
whole file at once (this allows parsing of big xml files with little
additional memory)
- automatically escapes/unescapes not allowed chars (>, <, ", &), thus
removes the most-hated "- escaping introduced in v1.0

Some usage examples:

uses Xml.VerySimple;
 
var
  Xml: TXmlVerySimple;
  Node, Child: TXmlNode;
begin
  Xml := TXmlVerySimple.Create;
  Xml.LoadFromFile('example.xml');
  Xml.Root.Find('book', 'id', 'bk102').Find('author').Text := 'Dein, Carol';
  Node := Xml.Root.AddChild('book');
  Child := Node.AddChild('author');
  Child.Text := 'Barger, Al';
  Child.Attribute['type'] := 'topseller';
  Node.AddChild('title').SetAttribute('lang', 'en').SetText('A big View');
  Xml.SaveToFile('output.xml');
  Xml.Free;
end;

VerySimpleXML supports just a subset of the XML specification

load and save from stream or file
nodes, childs and attributes
UTF-8 and ANSI encoding
compact output by setting Xml.Ident := ”;
method chaining
~~“>” and “>” inside text and attribute values when wrapped in quotation marks (XML-spec requires you to transform them into < etc.)~~now automatically escaped with v1.1

It does NOT support:

CDATA, comments, etc…

Example XML-file:

 version="1.0" encoding="utf-8" ?>
>
   id="bk101">
    >Gambardella, Matthew>
    />
     />
  >
   id=bk102 lang="en">
    >Ralls, Kim>
    >Midnight Rain>
    >A former architect battles corporate zombies>
    >
       lang="es">no-muerto>
       lang=en>zombies>
    >
  >
   id="bk103">
     rate=">5">Corets, Eva>
    >Maeve Ascendant>
    >The collapse of a > society>
  >
>

Warning! This is not a standard well-formed XML file (not all attributes are wrapped with quotation marks, < and > are used within attributes and text), it is an example of the (very simple) fault tolerance of VerySimpleXML. Version 1.1 automatically escapes all non allowed chars.

Solving circular unit references with class helpers

Dennis — Thu, 09 Jun 2011 08:39:45 +0000

Sooner or later you run into the circular unit reference problem when using a single unit for each class. There are some solutions (move the common used structs into a separate unit, use type casting, redesign your obvious bad class design, etc.) – this is a solution using class helpers. Recommended reading: “Class Helpers – good or bad ?” and “New Delphi language features since Delphi 7“:

“Class helpers provide a way to extend a class, but they should not be viewed as a design tool to be used when developing new code. They should be used solely for their intended purpose, which is language and platform RTL binding. “

Let’s suppose we have a simple TDog class:

unit Dog;
 
type
  TDog = class
    Name: String;
  end;

and a corresponding TMaster class:

unit Master;
 
type
  TMaster = class
    Name: String;
  end;

Let’s create our objects:

uses
  Dog, Master;
 
var
  Dog: TDog;
  Master: TMaster;
 
begin
  Dog := TDog.Create;
  Dog.Name := 'Bobby';
 
  Master := TMaster.Create;
  Master.Name := 'Joe';
end;

Works. Now we’re adding the dog’s master in our TDog class:

unit Dog;
 
uses
  Master;
 
type
  TDog = class
    Name: String;
    Master: TMaster;
  end;

Ok, compiles. Alright. Now what if we need a reference to our dog in the TMaster class? First approach:

unit Master;
 
uses
  Dog; // Compile error
 
type
  TMaster = class
    Name: String;
    Dog: TDog;
  end;

Won’t compile – circular unit reference (unit Dog uses unit Master, and unit Master uses unit Dog). You may getting around by using TObject as the Dog object:

  TMaster = class
    Name: String;
    Dog: TObject;
  end;

Well, that compiles – but you always have to type cast your Dog object:

[..]
begin
  Dog := TDog.Create;
  Dog.Name := 'Bobby';
 
  Master := TMaster.Create;
  Master.Name := 'Joe';
 
  Master.Dog := Dog;  // The Master has a dog
  Dog.Master := Master;  // The dog's master is Master
 
  Writeln(TDog(Master.Dog).Name);
end;

Now – how about using class helpers? First we move the Dog object into our protected area:

unit Master;
 
type
  TMaster = class
  protected
    FDog: TObject;
  public
    Name: String;
  end;

then we introduce a new class helper which “exports” the dog as a TDog class

unit MasterClassHelper;
 
uses
  Dog, Master;
 
type
  TMasterClassHelper = class helper for TMaster
  private
    procedure SetDog(Value: TDog);
    function GetDog: TDog;
  public
    property Dog: TDog read GetDog write SetDog;
  end;
 
function TMasterClassHelper.GetDog: TDog;
begin
  Result := TDog(FDog);  // We cast the TObject(FDog) to TDog!
end;
 
procedure TMasterClassHelper.SetDog(Value: TDog);
begin
  FDog := Value;
end;

Now we’re able to access the Dog reference of the Master object without typecasting:

uses
  Dog, Master, MasterClassHelper;
 
var
  Dog: TDog;
  Master: TMaster;
 
begin
  Dog := TDog.Create;
  Dog.Name := 'Bobby';
 
  Master := TMaster.Create;
  Master.Name := 'Joe';
 
  Master.Dog := Dog;  // The Master has a dog
  Dog.Master := Master;  // The dog's master is Master
 
  Writeln(Master.Dog.Name);  // "Bobby"
  Writeln(Dog.Master.Name);  // "Joe";
 
  Writeln(Dog.Master.Dog.Master.Dog.Master.Dog.Name); // "Bobby"
end;

Adding the MasterClassHelper in the implementation part of the Master unit allows us to access the TDog class inside our TMaster class, too:

unit Master;
 
type
  TMaster = class
  protected
    FDog: TObject;
  public
    Name: String;
    procedure RenameDog;
  end;
 
implementation
 
uses
  MasterClassHelper;
 
procedure TMaster.RenameDog;
begin
  Dog.Name := 'Buddy';
end;

Download Delphi source DogMaster.zip

Lua 5.1 for Delphi 2010

Dennis — Mon, 28 Sep 2009 18:36:18 +0000

This is a Lua 5.1 Wrapper for Delphi 2009 and Delphi 2010 which automatically creates OOP callback functions.

“Lua is a powerful, fast, lightweight, embeddable scripting language, it has been used in many industrial applications (e.g., Adobe’s Photoshop Lightroom), with an emphasis on embedded systems (e.g., the Ginga middleware for digital TV in Brazil) and games (e.g., World of Warcraft). Lua is currently the leading scripting language in games and it has a deserved reputation for performance. To claim to be “as fast as Lua” is an aspiration of other scripting languages.”

This Lua Wrapper is based on Lua-Pascal v0.2 by Marco Antonio Abreu
- converted PChar to PAnsiChar
- converted Char to AnsiChar
- added function LuaLibLoaded: Boolean;
- added a new base class (TLua) with OOP call back functions

Download
LuaDelphi2010-v1.3

History
1.3 Improved Callback, now uses pointer instead of object index. Modified RegisterFunctions to allow methods from other class to be registered, moved object table into TLua class
1.2 Added example on how to extend lua with a delphi dll
1.1 Improved global object table, optimized delphi function calls
1.0 Initial Release

Example
TLua automatically creates OOP callback functions for Delphi <-> Lua:

uses
  Lua, LuaLib;
 
type
  TMyLua = class(TLua)
  published
    function HelloWorld(LuaState: TLuaState): Integer;
  end;
 
function TMyLua.HelloWorld: Integer;
var
  ArgCount: Integer;
  I: integer;
begin
  writeln('Delphi: Hello World');
 
  ArgCount := Lua_GetTop(LuaState);
  writeln('Arguments: ', ArgCount);
  for I := 1 to ArgCount do
    writeln('Arg1', I, ': ', Lua_ToInteger(LuaState, I));
 
  // Clear stack
  Lua_Pop(LuaState, Lua_GetTop(LuaState));
 
  // Push return values
  Lua_PushInteger(LuaState, 101);
  Lua_PushInteger(LuaState, 102);
  Result := 2;
end;
 
var
  MyLua: TLua;
 
begin
  MyLua := TMyLua.Create;
  MyLua.DoFile('Helloworld.lua');
  MyLua.Free;
end;

helloworld.lua

print("LuaDelphi Test");
p1,p2 = HelloWorld(1,2,3)
print "Results:";
print (p1);
print (p2);

Unicode in Resource files

Dennis — Tue, 14 Oct 2008 15:20:22 +0000

Ever tried to put a unicode string (Delphi 2009) in a resource (.rc) file and tried to compile it with brcc32 or rc32?

You’ll get this error: Expecting resource name or resource type name

The Solution is very simple (though it kept me searching some hours :

Use

cgrc.exe

(CodeGear Resource Compiler/Binder) instead!