the1's WebLog

More on Getting the Number of Array Elements

2004-10-06T23:36:00Z

In a previous post, I discussed a safer way to get the number of elements in a C++ array. I mentioned that the countof() macro doesn’t work with local types (i.e. types defined inside a function definition).

I just realized that the macro also fails to work with anonymous types under certain circumstances. To be exact, If you call countof() on two arrays that have different anonymous types AND same size, then the second call will fail to compile.

e.g.

struct

{

int x;

} g_a[100];

struct

{

int x;

} g_b[100];

…

int g_size;

g_size = countof( g_a ); // First call - OK

g_size = countof( g_b ); // Second call - compiler ERROR!

The reason is that in this case, the second instantiation of the template helper function _ArraySizeHelper clashes with the first instantiation.

Note that if you change the size of g_b to something other than 100, it compiles fine.

So the caveat should be “countof() does not work with local types, and under certain circumstances does not work with anonymous types.”

I cannot believe it’s so difficult to get such a simple job (getting the number of array elements) done in C++.

What a broken language it is.

Programming in XSLT!

2004-08-20T21:31:00Z

Not so long ago, I posted a programming challenge, and received solutions in many different languages. Just when I thought people had forgot about this, I got this one from Anton Triest. It was written in a programming language called ... (surprise) XSLT!

Ask not what you can do in XSLT; ask what you cannot do in XSLT. :-)

(For those of you concerned that you need to buy an XSLT compiler to try it out, take heart -- all you need is your web browser)

Generalize Smart Pointers in C++

2004-08-06T20:11:00Z

After programming in C++ for a while, you will inevitably be introduced to the concept of “smart pointers” (or you will discover them on your own). These are pointers that know to automatically release the objects they point to when they (the pointers) are destructed. They have proved quite handy in avoiding memory leaks.

The most well known implementation of smart pointers probably is auto_ptr in STL and CAutoPtr in ATL, which will delete the object upon destruction.

auto_ptr and CAutoPtr are fine, but they have limitations:

Sometimes the pointer is not allocated via the new operator (e.g. malloc()). In these cases, you don’t want to use auto_ptr or CAutoPtr as the pointer will by wrongfully deleted (as opposed to be free()-ed in the case of malloc()).
They are good for wrapping pointers only. In general, you would like to allocate some resource and have the compiler release it for you automatically.

Why not generalize smart pointers to smart resource managers? It’s actually easy to do so. Here’s my take on this:

///////////////////////////////////////////////////////////

// Class CAutoResource

// An object of this template class holds a resource, and will dispose of

// the resource when it is destructed. This class is a generalization of

// auto_ptr in STL and CAutoPtr in ATL. The user must supply the function

// doing the disposition as a template parameter.

// Examples where this class can be useful include file/window/registry

// handles and pointers.

template< typename T, void (*Dispose)( T ), const T NullResource = 0>

class CAutoResource

{

public:

typedef T ResourceType;

CAutoResource( T Resource = NullResource )

: m_Resource( Resource )

{

}

~CAutoResource()

{

if ( NullResource != m_Resource )

{

Dispose( m_Resource );

}

operator T() const

{

return m_Resource;

}

T Get() const

{

return m_Resource;

}

void Attach( T NewResource )

{

Dispose( m_Resource );

m_Resource = NewResource;

}

// The assert on operator & usually indicates a bug.

T * operator & ()

{

_ASSERTE( NullResource == m_Resource );

return & m_Resource;

}

private:

T m_Resource;

CAutoResource( const CAutoResource& );

CAutoResource& operator = ( const CAutoResource& );

};

To use the CAutoResource template class, you need to supply:

The type of the resource;
A function that disposes of the resource; and
(Optional) The value that represents the “null” resource. If you don’t specify it, 0 is used.

Upon destruction, the resource in a CAutoResource object will be released by calling the resource disposition function.

I hope it becomes obvious to you that auto_ptr and CAutoPtr are basically special cases of CAutoResource where the disposition function is the delete operator. They do have more member functions, but those are not hard to add.

Let’s see some examples of using CAutoResource.

The first one is to wrap the generic Windows HANDLE, which is used by the Win32 API to represent a lot of different things (windows, fonts, brushes, memory, and etc). A typedef instantiates CAutoResource for this scenario:

#include <windows.h>

// Generic Windows handle

void DisposeHandle( HANDLE handle )

{

if ( NULL != handle )

{

CloseHandle( handle );

}

typedef CAutoResource< HANDLE, DisposeHandle > CAutoHandle;

Our second example is handle to a registry key:

// Handle to registry key

void DisposeHKey( HKEY hKey )

{

if ( NULL != hKey )

{

RegCloseKey( hKey );

}

typedef CAutoResource< HKEY, DisposeHKey > CAutoHKey;

Sometimes, two resources have the same C++ type but different semantics and should be released in different manners. For example, an HINTERNET should be released by either WinHttpCloseHandle() or InternetCloseHandle(), depending on whether it was allocated using the WinHttp or the WinINet API. This is no problem for us, as the disposition function is a type parameter to CAutoResource and you can specify different functions for the same C++ type:

#include <winhttp.h>

// Internet handle opened via the WinHttp API

void DisposeWinHttpHandle( HINTERNET handle )

{

if ( NULL != handle )

{

WinHttpCloseHandle( handle );

}

typedef CAutoResource< HINTERNET, DisposeWinHttpHandle > CAutoHWinHttp;

#include <wininet.h>

// Internet handle opened via the WinINet API

void DisposeHInternet( HINTERNET handle )

{

if ( NULL != handle )

{

InternetCloseHandle( handle );

}

typedef CAutoResource< HINTERNET, DisposeHInternet > CAutoHInternet;

Let’s give one example where the resource we want to manage is a pointer:

// Memory allocated via LocalAlloc() or LocalReAlloc()

void DisposeLocalMem( LPVOID lpMem )

{

if ( NULL != lpMem )

{

LocalFree( lpMem );

}

typedef CAutoResource< LPVOID, DisposeLocalMem > CAutoLocalMem;

So far so good, but as soon as you try to dereference a pointer masqueraded as a CAutoResource, you’ll find we haven’t defined the dereference operator (*) and the arrow operator (->) yet. This is because they don’t make sense in the context of general resources.

What we can do is to define these operators in a sub-class of CAutoResource. I would’ve called it CAutoPtr, but that name is taken, so instead we have CAutoPtrEx:

///////////////////////////////////////////////////////////

// Class CAutoPtrEx

// An object of this template class holds a pointer, and will dispose of

// the object pointed to when it is destructed. This class is a

// generalization of auto_ptr in STL and CAutoPtr in ATL.

// It is preferred to auto_ptr and CAutoPtr when 'delete' is not the right

// way to dispose of the object. The user must supply the function doing

// the disposition as a template parameter.

template< typename T, void (*Dispose)( T * ) >

class CAutoPtrEx : public CAutoResource< T *, Dispose, NULL >

{

public:

CAutoPtrEx( T * ptr = NULL )

: CAutoResource< T *, Dispose >( ptr )

{}

T& operator * () const

{

return *Get();

}

T * operator -> () const

{

return Get();

}

private:

CAutoPtrEx( const CAutoPtrEx& );

CAutoPtrEx& operator = ( const CAutoPtrEx& );

};

I’ll finish this article with an example using CAutoPtrEx:

// Memory allocated via CoTaskMemAlloc() or CoTaskMemRealloc()

template <typename T>

class CComMem

{

public:

static void Dispose( T * pMem )

{

if ( pMem )

{

::CoTaskMemFree( pMem );

}

typedef CAutoPtrEx< T, CComMem::Dispose > AutoPtr;

};

(This posting is provided "AS IS" with no warranties, and confers no rights.)

Top reasons for failing to download Visual Studio Express beta 1

2004-07-09T02:14:00Z

As you might know, now you can download Visual Studio express SKU's from here for free.

Since the release last Monday, we have seen that some users failed to download this product. The top reasons include:

1. The user cancelled the download.

Please be reminded that you are downloading a large product, for example, the documentation component (MSDN express) itself is over 150 MB. And, given the volume of download we are receiving, sometimes the progress will be very slow and it may look like hanging. Give it more time and you have a good chance of eventually finish the download.

2. The BITS service is disabled on the machine.

The VS express web setup relies on the BITS (Background Intelligent Transfer Service) service on the user's machine to download the setup files. BITS is enabled by default when you install Windows, but some user may choose to disable it for “performance gain”. This is not necessary as BITS is taking very little resource. You need to enable BITS before trying to install VS express over the web.

3. The user is not logged on.

Some users are trying to run VS express web setup under other's identity by using the “runas” command. This is not supported by BITS. You have to be logged on interactively. Another unsupported scenario is running the setup in a Terminal Server session into a Windows 2000 server machine. (Terminal Server into Windows XP and Windows 2003 server is fine.)

Improve Longhorn code quality

2004-07-09T01:57:00Z

Starting the coming Monday (July 12, 2004), I will be working for the Windows devision instead of Visual Studio. My new team is focusing on improving the quality of the Longhorn code base. I might write more about it once I get an idea on what it is really like there.

I would love to hear your suggestions and comments on best software development practice, and what you think we can do to improve the quality of a software project that involves millions of lines of code. Do you have a story to share? That would be great.

Welcome, Aaron!

2004-05-08T06:03:00Z

I'm glad to see Aaron Stebner started blogging about setup (installer).

Before Aaron switched team, he was a QA lead in the VS / .NET setup team, which I'm working for. He was a great resource then. Looks like his posts will be a new valuable source of information for my work. I expect them to be useful to anyone interested in setup technologies as well.

In particular, he recommended this article on MSI component rules written by Rob Mensching. It's 11pm and I need to rest now, but the first thing on Monday I'm gonna read it and save it in OneNote for future reference.

How Would You Get the Count of an Array in C++?

2004-05-08T00:56:00Z

The question is simple: given a C++ array (e.g. x as in int x[10]), how would you get the number of elements in it?

An obvious solution is the following macro (definition 1):

#define countof( array ) ( sizeof( array )/sizeof( array[0] ) )

I cannot say this isn’t correct, because it does give the right answer when you give it an array. However, the same expression gives you something bogus when you supply something that is not an array. For example, if you have

int * p;

then countof( p ) always give you 1 on a machine where an int pointer and an int have the same size (e.g. on a Win32 platform).

This macro also wrongfully accepts any object of a class that has a member function operator[]. For example, suppose you write

class IntArray

{

private:

int * p;

size_t size;

public:

int & operator [] ( size_t i );

} x;

then sizeof( x ) will be the size of the x object, not the size of the buffer pointed to by x.p. Therefore you won’t get a correct answer by countof( x ).

So we conclude that definition 1 is not good because the compiler does not prevent you from misusing it. It fails to enforce that only an array can be passed in.

What is a better option?

Well, if we want the compiler to ensure that the parameter to countof is always an array, we have to find a context where only an array is allowed. The same context should reject any non-array expression.

Some beginners may try this (definition 2):

template <typename T, size_t N>

size_t countof( T array[N] )

{

return N;

}

They figure, this template function will accept an array of N elements and return N.

Unfortunately, this doesn’t compile because C++ treats an array parameter the same as a pointer parameter, i.e. the above definition is equivalent to:

template <typename T, size_t N>

size_t countof( T * array )

{

return N;

}

It now becomes obvious that the function body has no way of knowing what N is.

However, if a function expects an array reference, then the compiler does make sure that the size of the actual parameter matches the declaration. This means we can make definition 2 work with a minor modification (definition 3):

template <typename T, size_t N>

size_t countof( T (&array)[N] )

{

return N;

}

This countof works very well and you cannot fool it by giving it a pointer. However, it is a function, not a macro. This means you cannot use it where a compile time constant is expected. In particular, you cannot write something like:

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

Can we do anything about it?

Someone (I don’t know who it is – I just saw it in a piece of code from an unknown author) came up with a clever idea: moving N from the body of the function to the return type (e.g. make the function return an array of N elements), then we can get the value of N without actually calling the function.

To be precise, we have to make the function return an array reference, as C++ does not allow you to return an array directly.

The implementation of this is:

template <typename T, size_t N>

char ( &_ArraySizeHelper( T (&array)[N] ))[N];

#define countof( array ) (sizeof( _ArraySizeHelper( array ) ))

Admittedly, the syntax looks awful. Indeed, some explanation is necessary.

First, the top-level stuff

char ( &_ArraySizeHelper( ... ))[N];

says “_ArraySizeHelper is a function that returns a reference (note the &) to a char array of N elements”.

Next, the function parameter is

T (&array)[N]

which is a reference to a T array of N elements.

Finally, countof is defined as the size of the result of the function _ArraySizeHelper. Note we don’t even need to define _ArraySizeHelper(), -- a declaration is enough.

With this new definition,

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

becomes valid, just as we desire.

Am I happy now? Well, I think this definition is definitely better than the others we have visited, but it is still not quite what I want. For one thing, it doesn’t work with types defined inside a function. That’s because the template function _ArraySizeHelper expects a type that is accessible in the global scope.

I don’t have a better solution. If you know one, please let me know.

BTW, how does one solve the same problem for C#? It’s trivial there. You just say “x.length()” (I forgot the actual syntax, but you should get the idea).

One thing to point out is that, in C# the count of an array is not in its type. You decide how many elements are there when you create the array at run time. Therefore, don’t even try to derive this information at compile time.

A JScript entry to the Phaser chanllenge

2004-04-07T00:48:00Z

You probably have got tired of me, and my phone number phraser chanllenge, but you should check this one out.

Today I got a JavaScript (!) program that solves the phraser problem from Nicholas Allen. This one is surprisingly short, and fairly clear too. I have to study JScript sometimes.

Note that JScript is not statically typed, which means many type errors will not be detected until run time. This is a major drawback to me. I strongly prefer to work in a type safe language that is statically typed. Actually, many times when you get rid of all type errors in a Haskell program, it just works – a good type system allows you to express so much!

Nicholas used a trie from letters to words. I would use a trie from digits to sets of words. Since more than one letters map to one digit, this change will result in a much smaller trie (there are much fewer keys) and a much faster algorithm (we look up a whole set of words, instead of a single word, at one time).

Here’s Nicholas’ message:

“I was reading over the solutions today and found the variety interesting. The Haskell method was very well done and really showed off the language well. Some of the great features of functional languages like lambda and apply are starting to appear in C-like languages so maybe one day everyone will be able to solve problems like this so pithily :)

Since I had a JavaScript solution written previously I thought I'd share it. It's amazing how many languages JS borrowed from in addition to Java. My solution uses a trie which I think was done fairly simply. It's a bit shorter than even the Haskell.

Note: to actually run this you'll need a JS interpreter that can handle files, such as Rhino.”

var number = "6423946369";

var letters = [,,{A:1,B:2,C:3},{D:1,E:2,F:3},{G:1,H:2,I:3},{J:1,K:2,L:3},

{M:1,N:2,O:3},{P:1,Q:2,R:3,S:4},{T:1,U:2,V:3},{W:1,X:2,Y:3,Z:4}];

var trie = [];

var words = readFile ("dict").toUpperCase ().split ("\n");

function add (node, word) {

if (!node [word [0]]) node [word [0]] = [];

if (word == "") node.isWord = true;

else add (node [word [0]], word.substr (1));

}

function find (node, word, number) {

if (number == "") {

if (node == trie || node.isWord) print (word);

return;

}

for (letter in letters [number [0]])

if (node [letter]) find (node [letter], word + letter, number.substr (1));

if (node.isWord) find (trie, word, number);

if (node == trie) find (trie, word + number [0], number.substr (1));

}

for (word in words) if (words [word] != "") add (trie, words [word]);

find (trie, "", number);

One more entry to the Phaser challenge

2004-04-06T23:54:00Z

Since I keep receiving entries to my programming challenge, I’ve compiled a list. New entries will be added to that list as they are received.

Last Saturday (4/3/04) I received another C# solution from Frans Bouma. In his own words:

“Hi,

This week I started my phraser solution in C#, and today I finished it. As you had to make it as clean as possible I did, and it might look somewhat verbose through the comments (no not // add 1 comments ;)).

The core phraser routine is just 34 lines with half of them { and } or comments.

I paste the complete code below. As a wordlist, you should simply use a textfile and on each line 1 word.

When you compile the code, simply run it like:

phraser.exe 6423946369 words.txt 2

where 2 is the maximum amount of digits. You can also specify -1 which means no limit.

The algo is performing ok and can be made even faster with a more clever hashtable setup, as I've explained in the comments :)

Cheers, and thanks for this fun compo. :)”

using System;

using System.Collections;

using System.IO;

namespace Phraser

{

/// <summary>

/// Phrase creator class, which creates all phrases possible of a phone number, using a word list.

/// The algorithm used: read all words in the wordlist and encode them into digit sequences (thus the

/// digit sequence required to form the word using the phone keyboard). Then match the digit sequences

/// with the phone number digits to find words in the phone number.

/// This is more efficient than the other algorithm: calculate all permutations of possible character

/// sequences which can be formed with the phone number.

/// </summary>

public class PhraseCreator

{

#region Class Member Declarations

private Hashtable _word2DigitSequence;

private string _phoneNumber, _wordListFilename;

private int _maxAmountOfDigitsInPhrase;

#endregion

#region Constructors

/// <summary>

/// Constructor.

/// </summary>

/// <param name="phoneNumber">The phone number to transform into phrases</param>

/// <param name="wordlistFilename">The filename with the english words to use in phrases.</param>

/// <param name="maxAmountOfDigitsInPhrase">The maximum amount of digits to be placed in the phrase.

/// -1 means unlimited.</param>

public PhraseCreator(string phoneNumber, string wordListFilename, int maxAmountOfDigitsInPhrase)

{

_phoneNumber = phoneNumber;

_wordListFilename = wordListFilename;

_word2DigitSequence = new Hashtable();

_maxAmountOfDigitsInPhrase = maxAmountOfDigitsInPhrase;

}

#endregion

#region Public methods

/// <summary>

/// Initializes the class for the phrasing process.

/// Loads wordlist and encodes all words read into digit sequences. Wordlists have to have 1 word per

/// line. Skips all words which are longer than the specified phonenumber.

/// </summary>

public void Initialize()

{

StreamReader reader = null;

string wordFromFile;

try

{

reader = new StreamReader(_wordListFilename);

// loop through the lines in the file. Each word is on a single line. Strip whitespace

while((wordFromFile = reader.ReadLine()) != null)

{

wordFromFile = wordFromFile.Trim();

if((wordFromFile.Length==0) || (wordFromFile.Length>_phoneNumber.Length))

{

// not valid.

continue;

}

// line read, each line contains 1 word. Create digit sequence for word read and store it in

// the hashtable.

wordFromFile = wordFromFile.ToLower();

// transform it to a digit sequence so we can use it for easy matching later.

string wordAsDigits = DigitizeWord(wordFromFile);

// store both in hashtable

if(!_word2DigitSequence.ContainsKey(wordFromFile))

{

_word2DigitSequence.Add(wordFromFile, wordAsDigits);

}

finally

{

reader.Close();

}

/// <summary>

/// Starts the phrasing process by calling the routine which dives into the recursion.

/// </summary>

public void StartPhrasingProcess()

{

DoCreatePhrases(0, "", 0);

}

#endregion

#region Private methods

/// <summary>

/// Creates all the possible phrases for the phone number passed in in the constructor.

/// It uses the read words in the file which filename was passed in in the constructor.

/// </summary>

/// <param name="startIndex">the current index to start scanning in the phonenumber</param>

/// <param name="phraseInProgress">the phrase which is currently being build</param>

/// <param name="currentAmountOfDigits">the current amount of digits in the phraseInProgress</param>

/// <remarks>

/// It uses a simple algorithm. It walks all words read and uses their digit sequence representations to

/// find them back in the phone number passed in starting with the first digit, and so on. If the current

/// digit in the phone number is not usable in any word, it is kept as a digit in the phrase. After the

/// complete wordlist has been processed for the current index, the digit is kept and the current index is

/// increased with 1. Until the end of the phone number is reached and recursion stops and back tracks. The

/// amount of digits is limited by the amount passed to the constructor. A '-' is placed between words.

/// <br><br>

/// It will write all found phrases to the console. Although the algorithm is very fast, it can be sped up

/// even more by constructing a hashtable with per digit (0-9) a list of words which digit sequence representations

/// start with that digit. This would greatly reduce the amount of words to loop through for each digit position.

/// </remarks>

private void DoCreatePhrases(int startIndex, string phraseInProgress, int currentAmountOfDigits)

{

if(startIndex >= _phoneNumber.Length)

{

// we have scanned the complete phonenumber through recursion. We can exit now by printing the phrase

// we've found to the console.

Console.WriteLine("Phrase found: {0}", phraseInProgress);

return;

}

string newPhraseInProgress = String.Empty;

foreach(DictionaryEntry wordDigitSequencePair in _word2DigitSequence)

{

string wordAsDigitSequence = (string)wordDigitSequencePair.Value;

// check if word matches the digits starting on startindex in phonenumber. If so, we have found a word.

if((startIndex + wordAsDigitSequence.Length) > _phoneNumber.Length)

{

// word can never match as it is longer than the remaining digits.

continue;

}

if(_phoneNumber.Substring(startIndex, wordAsDigitSequence.Length) == wordAsDigitSequence)

{

// Match found. Dive into recursion with this new phraseInProgress

DoCreatePhrases(startIndex + wordAsDigitSequence.Length, MakeNewCurrentPhrase(phraseInProgress,

wordDigitSequencePair.Key.ToString()), currentAmountOfDigits);

}

if((_maxAmountOfDigitsInPhrase == -1) || (_maxAmountOfDigitsInPhrase > currentAmountOfDigits))

{

// simply use the digit as a 'word' in the phrase and continue with the next digit. Then dive into recursion

// with this new phraseInProgress

DoCreatePhrases(startIndex+1, MakeNewCurrentPhrase(phraseInProgress, _phoneNumber[startIndex].ToString()),

currentAmountOfDigits+1);

}

/// <summary>

/// Creates a new phrase based on the two inputs. If the current phrase is empty, no '-' is emitted.

/// </summary>

/// <param name="currentPhrase">the current phrase we're working on</param>

/// <param name="wordToAdd">the new word to add to the current phrase</param>

/// <returns>new current phrase</returns>

private string MakeNewCurrentPhrase(string currentPhrase, string wordToAdd)

{

if(currentPhrase.Length > 0)

{

return currentPhrase + "-" + wordToAdd;

}

else

{

return wordToAdd;

}

/// <summary>

/// Transforms the passed in word into a sequence of digits, the same sequence which is required to press

/// on a phone keyboard to form the word.

/// </summary>

/// <param name="word">The word to transform into digits</param>

/// <returns>The word as a string of digits</returns>

/// <example>"nice" will be transformed into: "6423"</example>

private string DigitizeWord(string word)

{

// get word as characters

char[] wordAsCharacters = word.ToCharArray();

char[] wordAsDigitSequence = new char[wordAsCharacters.Length];

// digitize the word using CharacterToDigit

for (int i = 0; i < wordAsCharacters.Length; i++)

{

wordAsDigitSequence[i] = CharacterToDigit(wordAsCharacters[i]);

}

// create a new string from the digits which are stored as characters.

return new string(wordAsDigitSequence);

}

/// <summary>

/// Transforms the passed in character, which can be a member of the range a-z, to a digit, which can be

/// 2-9 (as only the keys 2-9 have characters on them on a phone keyboard).

/// </summary>

/// <param name="character">The character to transform into a digit</param>

/// <returns>The digit representation of the passed in character.</returns>

/// <example>'n' will be transformed into '6'</example>

private char CharacterToDigit(char character)

{

// set variable to return to a default: 2.

char digitToReturn = '2';

// do the transformation.

switch(character)

{

case 'a':

case 'b':

case 'c':

digitToReturn = '2';

break;

case 'd':

case 'e':

case 'f':

digitToReturn = '3';

break;

case 'g':

case 'h':

case 'i':

digitToReturn = '4';

break;

case 'j':

case 'k':

case 'l':

digitToReturn = '5';

break;

case 'm':

case 'n':

case 'o':

digitToReturn = '6';

break;

case 'p':

case 'q':

case 'r':

case 's':

digitToReturn = '7';

break;

case 't':

case 'u':

case 'v':

digitToReturn = '8';

break;

case 'w':

case 'x':

case 'y':

case 'z':

digitToReturn = '9';

break;

}

return digitToReturn;

}

#endregion

}

/// <summary>

/// Startup class for the application.

/// </summary>

public class Startup

{

/// <summary>

/// The main entry point for the application.

/// Expects 3 parameters:

/// parameter 1: phone number to phrase.

/// parameter 2: filename with English words.

/// parameter 3: max amount of digits to place in the phrase. can be -1, which means 0 maximum set.

/// </summary>

[STAThread]

static void Main(string[] args)

{

// check input

if(args.Length < 3)

{

// wrong amount of arguments

Console.WriteLine("Usage: Phraser Phonenumber Filename MaxAmountOfDigits" + Environment.NewLine +

"where 'Filename' is the file with words to use" + Environment.NewLine +

"where 'MaxAmountOfDigits is the maximum amount of digits to end up in the phrase. Can be -1 (no limit)");

return;

}

try

{

// 3 arguments specified. Create the phrases. Use the PhraseCreator class to do that.

PhraseCreator thePhraser = new PhraseCreator(args[0], args[1], Convert.ToInt32(args[2]));

thePhraser.Initialize();

// perform the phrasing

thePhraser.StartPhrasingProcess();

}

catch(Exception ex)

{

// display the exception in the console.

Console.WriteLine("Exception caught: {0}", ex.Message);

Console.WriteLine("Source: {0}", ex.Source);

Console.WriteLine("Stacktrace: {0}", ex.StackTrace);

}