menu
  Home  ==>  papers  ==>  colibri_utilities  ==>  delphi_net_bdsproj   

Delphi Net .BDSPROJ - Felix John COLIBRI.

  • abstract : presentation of the format and a tool analyzing the .BDSPROJ file of Delphi for .Net
  • key words : Delphi, .Net, Delphi 7, Delphi 8, Delphi 2005, configuration file, .DOF, .BDSPROJ, .XML, scanner, parser
  • software used : Windows XP, Delphi 6
  • hardware used : Pentium 1.400Mhz, 256 M memory, 140 G hard disc
  • scope : Delphi 7, Delphi 8, Delphi 2005
  • level : Delphi developer
  • plan :


1 - Introduction

When we started publishing papers with Delphi 8, we could no longer use our Delphi 6 utilities to package the .ZIP, since the .DOF is gone.

We had to analyze the .BDSPROJ file, and then could adapt the usual utilities.

This paper presents a .BDSPROJ analyzer which you might use to perform similar tasks.




2 - The .BDSPROJ analyzer

2.1 - The Delphi  Net files

When you use Delphi for .Net (Delphi 7, I assume, and Delphi 8, Delphi 2005), some of the auxiliary files have been changed.

Here are the main changes:

  • the .DOF (Delphi Option File) has been replaced with the .BDSPROJ
  • under Vcl.Net
    • the .DFM has been changed into an .NFM
  • under Windows.Forms
    • the .DFM has been changed into a .RESX
    • each tForm has an associated .TWinForm.resources
Other files will appear (.RSP, .IDENTCACHE) and the the compilation will generate
  • the .EXE and some .DCUIL (the equivalent of the .DCU)
  • other files (.PDB) and a MODEL folder containing some .TXVPCK


The bare minimum to rebuild the project seem to be
  • the .PAS
  • the .NFM or .RESX
  • the .DPR and the .BDSPROJ

2.2 - The Zipping problem

In order to build a self sufficient .ZIP, we used to analyze the .DPR, the .PAS and the .DOF to find all units directly or indirectly called by the project, copy the files to a new folder, change all pathes to relative pathes, check compilation using DCC, and Zip the whole thing.

Of course the whole thing fell apart since there is no .DOF any more.

Why has the .DOF be changed ? "To have a human readable configuration file". Well, to read the ASCII .DOF in .INI format, Notepad seemed to succeeded quite nicely. Yes, but it was not .XML.

Just changing the extension from .BDSPROJ to .TXT will allow you to examine the file's content. All that remains to be done is to analyze the .XML file to extract the pathes used by the project.

To analyze .XML, you have many Delphi solution, the Microsoft COM library, the DOM and other custom libraries. But to analyze such a small .XML file, we prefered to use our own simple parser, and this is what we are going to do now

2.3 - The .BDSPROJ format

The .BDSPROJ is an .XML file with
  • a three byte signature $EF $BB $BF
  • a <? xxx ?> format specifier (version and UTF-8)
  • the <BorlandProject> tag containing the configuration, in nested tags.
As already explained, if you wish to see the .BDSPROJ content, simply change the extension to .TXT and click on the file: NotePad will show it all.

 
  <?xml version="1.0" encoding="utf-8"?>
  <BorlandProject>
    <PersonalityInfo>
      <Option>
        <Option Name="Personality" Type="String">DelphiDotNet.Personality</Option>
        <Option Name="ProjectType" Type="String"></Option>
        <Option Name="Version" Type="String">1.0</Option>
        <Option Name="GUID" Type="String">{EE91EEC8-42C2-4E7C-AC35-49467C8B41B3}</Option>
      </Option>
    </PersonalityInfo>
    <DelphiDotNet.Personality>
      <Source>
       <Source Name="MainSource" Type="String">p_win_bdp_insert_data.dpr</Source>

The structure is the following:

  • personality: the kind of file
  • DelphiDotNet.Personality:
    • source name
    • compiler options
    • IDE options (ShowHint etc)
    • Linker options
    • Directories (this is the one we are looking for)
    • Parameters
    • Language
    • VersionInfo
  • VersionInfoKeys
  • FileList
To analyze the .BDSPROJ we used our simple scanner / parser combination.



2.4 - The XML Data

To parse any tagged text (.HTML, .XML or similar) you have two possibilities:
  • either call a user-event whenever you find some information
  • or to build a tree-like structure and let the user climb up and down this tree
Since we want to be able to rewrite the .BDSPROJ after some modifications, the tree seemed more natural.

Basically, an .XML file contains:

  • tags, like
         <file>
  • the tag is matched with an anti-tag:
         </file>
  • between the tags is some text:
         <file> Delphi </file>
  • the tag can contain some attributes
         <file version="1.234">
  • if the text is empty, the tag and the anti-tag can be collapsed in a single element
         <file version="1.234"/>
  • the text part can contain sub-tags
         <file> Delphi <source> compute.pas </source> </file>


In the following description we notice that the typical tag will look like

     <aaa> BBB <ccc> DDD <eee> FFFF </eee> </ccc> GGG <hhh/> </aaa>

where we find

  • the tag and anti-tag

         <aaa> BBB <ccc> DDD <eee> FFFF </eee> </ccc> GGG <hhh/> </aaa>  

  • the text between the markers

         <aaa> BBB <ccc> DDD <eee> FFFF </eee> </ccc> GGG <hhh/> </aaa>

    and the text is composed of:

    • strings

           <aaa> BBB <ccc> DDD <eee> FFFF </eee> </ccc> GGG <hhh/> </aaa>

    • sub-tags

           <aaa> BBB <ccc> DDD <eee> FFFF </eee> </ccc> GGG <hhh/> </aaa>

So the iterative part is in the text between <xxx> and </xxx>. In addition, in the case of .BDSPROJ, the anti-tag contains no attribute values.

To represent our .XML, we used

  • a c_xml_tag CLASS, with
    • the name of the tag (xxx)
    • a list of
      • strings (BBB, GGG)
      • sub-tags (ccc, hhh), which are themselves c_xml_tags
  • since the string / sub-tags are in a list, we used a common ancestor CLASS, which is here the c_xml_string. The c_xml_tag is a descendent of the c_xml_string CLASS
  • the attributes of the tag (the uuu="vvv" pairs) have been stored in two tStringLists
  • a c_xml_text contains both the comment and the main tag


The Delphi definitions are the following:
  • the c_xml_string:

    c_xml_stringClass(c_basic_object)
                    // -- m_name: the string

                    Constructor create_xml_string(p_nameString);
                    function f_display_xml_stringString;
                    function f_c_selfc_xml_string;
                  end// c_xml_string

  • the c_xml_tag is defined as:

    c_xml_tagClass(c_xml_string)
                 // -- m_name: the tag name

                 // -- the key="value" lists
                 m_c_key_listm_c_value_listtStringList;

                 // -- the (optional) content between <xxx> and </xxx>
                 m_c_xml_tag_content_listc_xml_tag_content_list;

                 Constructor create_xml_tag(p_nameString);
                 function f_c_selfc_xml_tag;

                 procedure add_attribute(p_keyp_valueString);

                 function f_display_xml_tagString;
                 function f_display_xml_name_and_attributesString;
                 procedure display_strings;
                 procedure display_xml_tag;

                 function f_contains_stringBoolean;
                 function f_key_value(p_keyString): String;
                 function f_c_get_strings_listtStringList;

                 Destructor DestroyOverride;
               end// c_xml_tag

  • the iterative elements are encapsulated in a tSringList

    c_xml_tag_content_listClass(c_basic_object)
                              m_c_xml_tag_content_listtStringList;

                              Constructor create_xml_tag_content_list(p_nameString);

                              function f_xml_tag_content_countInteger;
                              function f_c_xml_tag_content(p_xml_tag_content_indexInteger): c_xml_string;
                              function f_index_of(p_xml_tag_content_nameString): Integer;
                              procedure add_xml_string(p_c_xml_stringc_xml_string);

                              function f_c_find_by_xml_tag_content(p_xml_tag_content_nameString): c_xml_tag;
                              procedure display_xml_tag_content_list;

                              function f_contains_stringBoolean;
                              procedure display_strings;
                              function f_c_get_strings_listtStringList;

                              Destructor DestroyOverride;
                            end// c_xml_tag_content_list

  • the whole file is represented by:

    c_xml_textClass(c_basic_object)
                  m_c_xml_commentc_xml_tag;
                  m_c_xml_contentc_xml_tag;

                  Constructor create_xml_text(p_nameString);
                  procedure display_xml_text;
                  Destructor DestroyOverride;
                end// c_xml_text




In UML notation, the class diagram is the following:



2.5 - The XML Scanner

The basic tokens are:
  • the XML markers < > /> </ <? ?>
  • the tag content punctuations . =
  • the identifiers
  • the strings
Our scanner then defines the following symbol types:

type t_symbol_type= (e_unknown_symbol,
                  e_string_symbol,
                  e_integer_symbol,
                  e_identifier_symbol,
                  e_free_text_symbol,

                  e_text_symbol// -- anything but <

                  e_opening_tag_symbol,
                  e_closing_tag_symbol,
                  e_point_symbol,
                  e_equal_symbol,

                  e_opening_anti_tag_symbol// </
                  e_closing_anti_tag_symbol// />
                  e_comment_start_symbol// <?
                  e_comment_end_symbol// ?>

                  e_end_symbol
                  );

The main loop is the classical CASE:

case m_pt_buffer[m_buffer_indexof
  '<' : if (m_buffer_index+ 1< m_buffer_size)
          and (m_pt_buffer[m_buffer_index+ 1]= '/')
            then get_2_operator_symbol(e_opening_anti_tag_symbol)
            else
              if (m_buffer_index+ 1< m_buffer_size)
                  and (m_pt_buffer[m_buffer_index+ 1]= '?')
                then get_2_operator_symbol(e_comment_start_symbol)
                else get_operator_symbol(e_opening_tag_symbol);
  '>' : get_operator_symbol(e_closing_tag_symbol);
  '/' : if (m_buffer_index+ 1< m_buffer_size)
          and (m_pt_buffer[m_buffer_index+ 1]= '>')
            then get_2_operator_symbol(e_closing_anti_tag_symbol)
            else get_operator_symbol(e_closing_tag_symbol);
  '?' : if (m_buffer_index+ 1< m_buffer_size)
          and (m_pt_buffer[m_buffer_index+ 1]= '>')
            then get_2_operator_symbol(e_comment_end_symbol)
            else get_unknown_symbol;
  '=' : get_operator_symbol(e_equal_symbol);
  '.' : get_operator_symbol(e_point_symbol);
  '"' : get_string_symbol;
  'a'..'z''A'..'Z' : get_identifier;

  else
    get_unknown_symbol
end// case

and, as an example, the procedure to get the litteral string:

procedure get_string_symbol;
    // -- the string without the quotes
  var l_start_indexInteger;
  begin
    // -- remember the first character after the quote
    l_start_index:= m_buffer_index+ 1;

    repeat
      inc(m_buffer_index);
    until (m_buffer_index>= m_buffer_size)
        or (m_pt_buffer[m_buffer_index]= '"');

    m_symbol_string:= f_extract_string_start_end(l_start_indexm_buffer_index- 1);
    m_symbol_type:= e_string_symbol;

    // -- skip closing "
    inc(m_buffer_index);
  end// get_string_symbol



The scanner class is defined as:

c_xml_scannerclass(c_text_file)
                 m_blank_stringString;
                 m_symbol_stringString;
                 m_symbol_typet_symbol_type;

                 m_c_unknown_symbol_listtStringList;

                 constructor create_xml_scanner(p_name,
                     p_file_nameString);

                 procedure display_error(p_textString);
                 procedure get_symbol;
                 procedure get_text_symbol;
                 procedure test_scanner(p_displayBoolean);

                 destructor DestroyOverride;
               end// c_xml_scanner

where

  • get_symbol and get_text_symbol are the procedures called by the parser
  • test_scanner simply scans the whole text, and m_c_unknown_symbol_list shows unrecognized symbols, if any


2.6 - The XML parser

We started with the following .XML grammar (nested EBNF):

 
xml_document= comment tag_content .
    tag_name= NAME [ '.' NAME ] .
    tag_name_and_attributes= tag_name { NAME '=' STRING } .
    comment= '<?' tag_name_and_attributes '?>' .
    tag_content= '<' tag_name_and_attributes ( '>' { any | tag_content } '</' tag_name '>' | '/>' ) .
        any= ANY_BUT ('<') .



Our compiler's compiler generated the base recursive descent parsing, and we only had to add the tree building lines.

Here is the parser definition:

c_xml_parserclass(c_basic_object)
                m_c_xml_scanner_refc_xml_scanner;

                constructor create_xml_parser(p_nameString;
                    p_c_xml_scanner_refc_xml_scanner);
                procedure parse_xml(p_c_xml_textc_xml_text);
              end// c_xml_parser

and, as an example, the parsing and building of a tag:

function f_c_parse_tag_content_recursivec_xml_tag;
  var l_c_xml_sub_tagc_xml_tag;
      l_c_xml_stringc_xml_string;
  BEGIN
    check(e_opening_tag_symbol);
    read_symbol;

    Result:= f_c_parse_tag_name_and_attributes;

    IF l_symbol_typee_closing_tag_symbol
      THEN BEGIN
          // -- skip ">"
          read_text_symbol;

          // -- await "</"
          while l_symbol_type<> e_opening_anti_tag_symbol do
          begin
            IF l_symbol_typee_opening_tag_symbol
              THEN begin
                  l_c_xml_sub_tag:= f_c_parse_tag_content_recursive;
                  Result.m_c_xml_tag_content_list.add_xml_string(l_c_xml_sub_tag);
                end
              else begin
                  // -- any content, but skip blanks
                  if not f_contains_only(l_symbol_string, [' 'k_tabulationk_returnk_line_feed])
                    then begin
                        l_c_xml_string:= c_xml_string.create_xml_string(l_symbol_string);
                        Result.m_c_xml_tag_content_list.add_xml_string(l_c_xml_string);
                      end;

                  read_symbol;
                end;
          end// while

          // -- skip "</"
          check(e_opening_anti_tag_symbol);
          read_symbol;

          f_parse_tag_name;
          check(e_closing_tag_symbol);

          read_symbol;
        END // closing simple
      ELSE
        IF l_symbol_typee_closing_anti_tag_symbol
          THEN
            read_symbol
          ELSE display_parser_error('>, />');
  END// f_c_parse_tag_content_recursive



2.7 - The display of the Directories

Here is an example or the client program:

procedure analyze_all_xml;
  var l_c_xml_scannerc_xml_scanner;
      l_c_xml_textc_xml_text;
  begin
    l_c_xml_scanner:= c_xml_scanner.create_xml_scanner('scanner',
        g_source_pathg_file_name);
    l_c_xml_text:= c_xml_text.create_xml_text('xml_text');

    with c_xml_parser.create_xml_parser('parser'l_c_xml_scannerdo
    begin
      m_trace_paser:= True;

      parse_xml(l_c_xml_text);

      Free;
    end// with c_xml_parser

    with l_c_xml_text do
    begin
      display_xml_text;
      Free;
    end;
  end// analyze_all_xml



Here is a snapshot of the application:



And the partial result of the program looks like this:

 
> BorlandProject
  > PersonalityInfo
    > Option
      > Option [Name=Personality Type=String]
        DelphiDotNet.Personality
      > Option [Name=ProjectType Type=String]
      > Option [Name=Version Type=String]
        1.0
      > Option [Name=GUID Type=String]
        {EE91EEC8-42C2-4E7C-AC35-49467C8B41B3}
  > DelphiDotNet.Personality
    > Source
      > Source [Name=MainSource Type=String]
        p_win_bdp_insert_data.dpr
    > FileVersion
      > FileVersion [Name=Version Type=String]
        7.0



This is very similar to what NotePad presented. But we have a tree structure which will be very simple to use in order to extract the pathes, or even to replace some information. In the companion paper, we will present how to generate a DCCIL .BAT file.




3 - Some Open Questions

You will notice that the .BDSPROJ structure closely follows the Project | Options dialog organization.

There are a couple of points which I could not explain:

  • why does the .DPR includes some informations that already reside in the .BDSPROJ ?
  • I've heard that the .DPR is only present for backward compatibility and historical reasons. Is this true ? I continue to start a project by clicking on the .DPR in a Windows File Explorer, but Delphi always presents the .BDSPROJ when I select "reopen project"
  • When started programming with Delphi 8, I purchased the Pacheco book. I have their "developer's guides" since Delphi 2. I then tried out a couple of examples. When I started a new project, I used "save as" in a new folder, renaming the project and the unit. However the .DOF, AND the .DPR kept the note about the Texeira previous visit:

    <FileList>
    <File FileName="C:\prog\delphi_8\_pacheco\Chapter 24\Ex04\ WinForm.resx" ContainerId="ResXCompiler" ModuleName="WinForm" Parent="C:\prog\delphi_8\ _pacheco\Chapter 24\Ex04\WinForm.pas">

    Although I am not ashamed of having tried a program from a book I purchased, I not sure that I would be glad to see my customers finding references about other projects I am working on in the sources I send them.

    We used to clean up the .DOF of any "history" entries (search, replace, file list etc). So we will do the same for the .BDSPROJ. But since there is now some duplication with the .DPR, we will need to also cleanup the .DPR.

  • the Delphi for Net versions use project groups. Those groups existed since at least Delphi 5 now. I never used them, feeling that I already have enough work with one project. But in Delphi for Net, this group seems to be mandatory. Is there a way to get rid of this ?
  • in addition, the "save as" does not work as in Delphi 6:
    • under Windows, each Process has a current path. When we change the current path, all reading and writing of files without a path qualifier will be done in this current path
    • when we wanted to build a new version of a project
      • we used "save project as", changing the path, which then became the current path
      • we used "save as" for all the units, which would be saved in the current path
    • under Delphi for Net, you can use "save project as" to save the project in a new path. But "save as" for the units keeps the units in their original path (and does NOT put them in the new current path)
    I assume this is related to the "Project Group" issue: people working on many projects at the same time might not want to save renamed units from Project1 in the "current path" which might be the path or Project2.
    Why are we raising this issue here ? Because when we copied the new project, in some cases the .DPR kept a reference of a previous unit from another path in its USES list. This naturally caused havock with our DCCIL compilation. So we will have to check this also.
    Does anybody knows whether there is a way to get the old "current path" behaviour ?



4 - Download the Sources

Here are the source code files: The .ZIP file(s) contain:
  • the main program (.DPR, .DOF, .RES), the main form (.PAS, .DFM), and any other auxiliary form
  • any .TXT for parameters, samples, test data
  • all units (.PAS) for units
Those .ZIP
  • are self-contained: you will not need any other product (unless expressly mentioned).
  • for Delphi 6 projects, can be used from any folder (the pathes are RELATIVE)
  • will not modify your PC in any way beyond the path where you placed the .ZIP (no registry changes, no path creation etc).
To use the .ZIP:
  • create or select any folder of your choice
  • unzip the downloaded file
  • using Delphi, compile and execute
To remove the .ZIP simply delete the folder.

The Pascal code uses the Alsacian notation, which prefixes identifier by program area: K_onstant, T_ype, G_lobal, L_ocal, P_arametre, F_unction, C_lass etc. This notation is presented in the Alsacian Notation paper.



As usual:

  • please tell us at fcolibri@felix-colibri.com if you found some errors, mistakes, bugs, broken links or had some problem downloading the file. Resulting corrections will be helpful for other readers
  • we welcome any comment, criticism, enhancement, other sources or reference suggestion. Just send an e-mail to fcolibri@felix-colibri.com.
  • or more simply, enter your (anonymous or with your e-mail if you want an answer) comments below and clic the "send" button
    Name :
    E-mail :
    Comments * :
     

  • and if you liked this article, talk about this site to your fellow developpers, add a link to your links page ou mention our articles in your blog or newsgroup posts when relevant. That's the way we operate: the more traffic and Google references we get, the more articles we will write.



5 - Conclusion

We presented a very simple .XML parser to explore the .BDSPROJ configuration file used by Delphi 7, Delphi 8 and Delphi 2005.




6 - References

  • Xavier PACHECO (editor)
        Delphi for .NET - Developper's Guide
          Sams - ISBN 0 672 32443 - 1 - 2004
        The equivalent of Petzold's books to start on the .Net platform with Delphi



7 - Other Papers with Source and Links

Database
database reverse engineering Extraction of the Database Schema by analyzing the content of the application's .DFMs
sql parser Parsing SQL requests in Delphi, starting from an EBNF grammar for SELECT, INSERT and UPDATE
ado net tutorial a complete Ado Net architectural presentation, and projects for creating the Database, creating Tables, adding, deleting and updating rows, displaying the data in controls and DataGrids, using in memory DataSets, handling Views, updating the Tables with a DataGrid
turbo delphi interbase tutorial develop database applications with Turbo Delphi and Interbase. Complete ADO Net architecture, and full projects to create the database, the Tables, fill the rows, display and update the values with DataGrids. Uses the BDP
bdp ado net blobs BDP and Blobs : reading and writing Blob fields using the BDP with Turbo Delphi
interbase stored procedure grammar Interbase Stored Procedure Grammar : The BNF Grammar of the Interbase Stored Procedure. This grammar can be used to build stored procedure utilities, like pretty printers, renaming tools, Sql Engine conversion or ports
using interbase system tables Using InterBase System Tables : The Interbase / FireBird System Tables: description of the main Tables, with their relationship and presents examples of how to extract information from the schema
eco tutorial Writing a simple ECO application: the UML model, the in memory objects and the GUI presentation. We also will show how to evaluate OCL expressions using the EcoHandles, and persist the data on disc
delphi dbx4 programming the new dbExpress 4 framework for RAD Studio 2007 : the configuration files, how to connect, read and write data, using tracing and pooling delegates and metadata handling
blackfishsql using the new BlackfishSql standalone database engine of RAD Studio 2007 (Win32 and .Net) : create the database, create / fill / read Tables, use Pascal User Defined Functions and Stored Procedures
rave pdf intraweb how to produce PDF reports using Rave, and have an Intraweb site generate and display .PDF pages, with multi-user access
embarcadero er studio Embarcadero ER Studio tutorial: how to use the Entity Relationship tool to create a new model, reverse engineer a database, create sub-models, generate reports, import metadata, switch to Dimensional Model
Web
sql to html converting SQL ascii request to HTML format
simple web server a simple HTTP web Server and the corresponding HTTP web Browser, using our Client Server Socket library
simple cgi web server a simple CGI Web Server which handles HTML <FORM> requests, mainly for debugging CGI Server extension purposes
cgi database browser a CGI extension in order to display and modify a Table using a Web Browser
whois a Whois Client who requests information about owners of IP adresses. Works in batch mode.
web downloader an HTTP tool enabling to save on a local folder an HTML page with its associated images (.GIF, .JPEG, .PNG or other) for archieving or later off-line reading
web spider a Web Spider allowing to download all pages from a site, with custom or GUI filtering and selection.
asp net log file a logging CLASS allowing to monitor the Asp.Net events, mainly used for undesrtanding, debugging and journaling Asp.Net Web applications
asp net viewstate viewer an ASP.NET utility displaying the content of the viewtate field which carries the request state between Internet Explorer and the IIS / CASSINI Servers
rss reader the RSS Reader lets you download and view the content of an .RSS feed (the entry point into somebody's blog) in a tMemo or a tTreeView. Comes complete with an .HTML downloader and an .XML parser
news message tree how to build a tree of the NNTP News Messages. The downloaded messages are displayed in tListBox by message thread (topic), and for each thread the messages are presented in a tTreeVi"ew
threaded indy news reader a NewsReader which presents the articles sorted by thread and in a logical hierarchical way. This is the basic Indy newsreader demo plus the tree organization of messages
delphi asp net portal programming presentation, architecture and programming of the Delphi Asp Net Portal. This is a Delphi version of the Microsoft ASP.NET Starter Kit Web Portal showcase. With detailed schemas and step by step presentation, the Sql scripts and binaries of the Database
delphi web designer a tiny Delphi "RAD Web Designer", which explains how the Delphi IDE can be used to generate .HTML pages using the Palette / Object Inspector / Form metaphor to layout the page content
intraweb architecture the architecture of the Intraweb web site building tool. Explains how Delphi "rad html generator" work, and presents the CLASS organization (UML Class diagrams)
ajax tutorial AJAX Tutorial : writing an AJAX web application. How AJAX works, using a JavaScript DOM parser, the Indy Web Server, requesting .XML data packets - Integrated development project
asp net master pages Asp.Net 2.0 Master Pages : the new Asp.Net 2.0 allow us to define the page structure in a hierarchical way using Master Pages and Content Pages, in a way similar to tForm inheritance
delphi asp net 20 databases Asp.Net 2.0 and Ado.Net 2.0 : displaying and writing InterBase and Blackfish Sql data using Dbx4, Ado.Net Db and AdoDbxClient. Handling of ListBox and GridView with DataSource components
asp net 20 users roles profiles Asp.Net 2.0 Security: Users, Roles and Profiles : Asp.Net 2.0 offers a vaslty improved support for handling security: new Login Controls, and services for managing Users, grouping Users in Roles, and storing User preferences in Profiles
bayesian spam filter Bayesian Spam Filter : presentation and implementation of a spam elimination tool which uses Bayesian Filtering techniques
TCP/IP
tcp ip sniffer project to capture and display the packets travelling on the Ethernet network of your PC.
sniffing interbase traffic capture and analysis of Interbase packets. Creation of a database and test table, and comparison of the BDE vs Interbase Express Delphi components
socket programming the simplest Client Server example of TCP / IP communication using Windows Sockets with Delphi
delphi socket architecture the organization of the ScktComp unit, with UML diagrams and a simple Client Server file transfer example using tClientSocket and tServerSocket
Object Oriented Programming Components
delphi virtual constructor VIRTUAL CONSTRUCTORS together with CLASS references and dynamic Packages allow the separation between a main project and modules compiled and linked in later. The starting point for Application Frameworks and Plugins
delphi generics tutorial Delphi Generics Tutorial : using Generics (parameterized types) in Delphi : the type parameter and the type argument, application of generics, constraints on INTERFACEs or CONSTRUCTORs
UML Patterns
the lexi editor delphi source code of the Gof Editor: Composite, Decorator, Iterator, Strategy, Visitor, Command, with UML diagrams
factory and bridge patterns presentation and Delphi sources for the Abstract Factory and Bridge patterns, used in the Lexi Document Editor case study from the GOF book
gof design patterns delphi source code of the 23 Gof (GAMMA and other) patterns: Composite, Decorator, Iterator, Strategy, Visitor, Command
Debug and Test
Graphic
delphi 3d designer build a 3d volume list, display it in perspective and move the camera, the screen or the volumes with the mouse.
writing a flash player build your own ShockWave Flash movie Player, with pause, custom back and forward steps, snapshots, resizing. Designed for analyzing .SWF demos.
Utilities
the coliget search engine a Full Text Search unit allowing to find the files in a directory satisfying a complex string request (UML AND Delphi OR Patters)
treeview html help viewer Treeview .HTML Help Viewer : the use of a Treeview along with a WebBrowser to display .HTML files alows both structuring and ordering of the help topics. This tool was used to browse the Delphi PRISM Wiki help.
Delphi utilities
delphi net bdsproj structure and analysis of the .BDSPROJ file with the help of a small Delphi .XML parser
dccil bat generator generation of the .BAT for the Delphi DCCIL command line compiler using the .BDSPROJ
dfm parser a Delphi Project analyzing the .DFM file and building a memory representation. This can be used for transformations of the form components
dfm binary to text a Delphi Project converting all .DFM file from a path from binary to ascii format
component to code generate the component creation and initialization code by analyzing the .DFM. Handy to avoid installing components on the Palette when examining new libraries
exe dll pe explorer presents and analyzes the content of .EXE and .DLL files. The starting point for extracting resources, spying .DLL function calls or injecting additional functionalities
dll and process viewer analyze and display the list of running processes, with their associated DLLs and Memory mapped files (Process Walker)
Controls
find memo a tMemo with "find first", "find next", "sort", "save" capabilities
Helper units
windows environment read and write Windows Environment strings
stdin stdout send and receive strings from a GUI application to a CONSOLE application




8 - The author

Felix John COLIBRI works at the Pascal Institute. Starting with Pascal in 1979, he then became involved with Object Oriented Programming, Delphi, Sql, Tcp/Ip, Html, UML. Currently, he is mainly active in the area of custom software development (new projects, maintenance, audits, BDE migration, Delphi Xe_n migrations, refactoring), Delphi Consulting and Delph training. His web site features tutorials, technical papers about programming with full downloadable source code, and the description and calendar of forthcoming Delphi, FireBird, Tcp/IP, Web Services, OOP  /  UML, Design Patterns, Unit Testing training sessions.
Created: nov-04. Last updated: mar-2017 - 94 articles, 229 .ZIP sources, 1183 figures
Copyright © Felix J. Colibri   http://www.felix-colibri.com 2004 - 2017. All rigths reserved
Back:    Home  Papers  Training  Delphi developments  Links  Download
the Pascal Institute

Felix J COLIBRI

+ Home
  + articles_with_sources
    + database
    + web_internet_sockets
    + oop_components
    + uml_design_patterns
    + debug_and_test
    + graphic
    + controls
    + colibri_utilities
      – delphi_net_bdsproj
      – dccil_bat_generator
      – coliget_search_engine
      – dfm_parser
      – dfm_binary_to_text
      – component_to_code
      – exe_dll_pe_explorer
      – dll_process_viewer
      – the_alsacian_notation
      – html_help_viewer
      – cooking_the_code
      – events_record_playback
      – colibri_hiragana_quiz
    + colibri_helpers
    + delphi
    + firemonkey
    + compilers
    + vcl
  + delphi_training
  + delphi_developments
  + sweet_home
  – download_zip_sources
  + links
Contacts
Site Map
– search :

RSS feed  
Blog