Couple of weeks ago, I needed to parse a set of XML files. As always, my first thought was to search the web for free XML parsers. But then I remembered that I found a solution in the past: Xerces XML parser. Even though, xerces was originally written in Java, there is an excellent port to c/c++. Xerces was developed by Apachi Software Foundation, and it supports wide range of compilers. To use it with Visual Studio 2005 C++ compiler, following steps are required:

1. Download compiler in binary form from here;
2. Unpack into any folder; This step will create subfolders include and lib;
   
3. Add path include and lib folders to VC++ directories;
4. To statically link to a project, link with xerces-c_static_2.lib or (xerces-c_static_2D.lib for debug version);
5. Set to ignore libcmt.lib

Steps 4 and 5 are shown in the screen shot below:

Couple of days ago, I worked on an MFC application that required special functionallity of F1 key. At first, I thought that all I need is to override application's PreTranslateMessage function and trap the F1 key. However, I was wrong. Every time I pressed F1 key, the application performed custom function, but also popped message box saying that help file could not be located. My first thought was that MFC/Windows is placing a windows hook to trap such functionality and that the workaround might not be very elegant. Fortunatly that was not the case. After some investigation, I noticed the following code:

BEGIN_MESSAGE_MAP(CDRSApp, CWinApp)
    ON_COMMAND(ID_HELP, &CWinApp::OnHelp)
END_MESSAGE_MAP()

In other words, main application is getting notification to handle help request and is passing it to default MFC implementation. Once the ON_COMMAND line is commented out, such hadling is disabled.

Abstract

The compiler design is a well researched area of computer science. Typically, compiler designers use a parser generator framework like YACC or PCCTS to construct lexer, scanner, parser, and abstract syntax tree. With the arrival of expression templates and template meta-programming, it is possible to construct a parser by simply using the template meta-programming technique. The Spirit library is object-oriented recursive-decent parser implemented in C++ using expression templates and meta-programming. In Spirit the parser is constructed during the compile time using a combination of primitive parsers and fusing them through template meta-programming. TinyPascal is a practical application of Spirit framework.
More...

Introduction

According to one of expression templates inventors, Todd Veldhuizen, expression templates are “new C++ technique for passing expressions as functions arguments” [1]. The purpose of expression template is to inline expressions during compilation, which produces faster and arguably more readable code. Most of expression template articles focus on numeric array classes and operations on those using expression template techniques. For instance, expression templates could be utilized for matrix multiplication without using temporaries. For such article and code examples, please refer to articles referenced under [1] and [2].

As probably suspected, this article will not focus on expression templates as applied on numeric array classes. In this article, the focus will be on parsing and language recognition using expression template techniques. Furthermore the article will focus on Spirit library [3], a parser framework implemented completely using expression templates and template meta-programming. At this point the reader is encouraged to refer to introductory part of Spirit documentation as found here http://www.boost.org/libs/spirit/doc/introduction.html.

In addition it is important to note that this article will not focus on all parts of Spirit framework. This article is rather attempt to explain fundamentals behind expression templates as applied in Spirit framework.
More...

Occasionally an application execution depends on installed devices. For example, USB memory card might be needed for storing/reading application specific files. But how do we know that such device is inserted/installed on the system?

Below is the code that enumerates all installed devices on a windows system.

HDEVINFO hInfoList = ::SetupDiGetClassDevs(NULL, NULL, NULL,
        DIGCF_PRESENT | DIGCF_ALLCLASSES | DIGCF_PROFILE);
if(hInfoList != INVALID_HANDLE_VALUE)
{
    SP_DEVINFO_DATA spdid;
    spdid.cbSize = sizeof(SP_DEVINFO_DATA); 

    DWORD dwIndex = 0;
    while(::SetupDiEnumDeviceInfo(hInfoList, dwIndex, &spdid))
    {
        CString strEntry = _T(""); 

        TCHAR szName[4096] = {0}; 

        if(::SetupDiGetClassDescription(&spdid.ClassGuid, 
                                        szName, 
                                        4096, 
                                        NULL))
        strEntry += szName;
        strEntry += " | "; 

        if(::SetupDiGetDeviceRegistryProperty(hInfoList, &spdid, SPDRP_DEVICEDESC, 0,
            (PBYTE)szName, 4096, 0))
        {
            strEntry += szName;
        }
        
        strEntry += " | "; 

        if(::SetupDiGetDeviceRegistryProperty(hInfoList, 
                &spdid, SPDRP_FRIENDLYNAME, 0, 
                (PBYTE)szName, 4096, 0))
        {
            strEntry += szName;
        } 

        m_DevList.AddString(strEntry); 

        ++dwIndex;
    }
} 

::SetupDiDestroyDeviceInfoList(hInfoList);

Couple of days ago I was asked by a fellow software developer the question regarding endianess of host machine. The question was if there is an easy way to determine if a host machine is little or big endian. At first, I was somewhat shocked that such a simple question was not already answered throughout his carrier. But then I realized that he is a VB developer (no offense intended) and that he never had to deal with questions like this. Also, I realized with growing popularity of .NET and Java, the separation between software implementation and hardware is growing exponentially. It is reality that some software developers will probably spend whole life developing successful applications without even knowing that endianess exists. Is this a good or bad thing, I leave the reader to decide.

Getting back to the question, I wrote little example that would determine if machine is little or big endian. Here is the code:

#include <iostream>
using namespace std; 

int main(int argc, char* argv[])
{
    unsigned int x = 0x00000001;
    unsigned char *p = (unsigned char*)&x;
    if(p[0]=1)
        cout << "The machine is little-endian" << endl;
    else cout << "The machine is big-endian" << endl; 

    return 0;
}