Command Interpreter

[Absolution]

Since people have recently been releasing various tools/libraries to help with hack development. . . why not throw another interpreter in the mix. The most interesting thing of this is probably the regex - other than that, its not that different from what people have done before. . .

Interpreter.cpp

/*
Game-Deception Property License 1.0
2005-2008 Game-Deception( www.gamedeception.net )

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR Copyright   HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN REGARD TO THE SOFTWARE.

Permission is hereby granted, free of charge, to any person obtaining a copy of this
software and associated documentation files (the "Software"), to deal in the Software
without restriction, including without limitation the rights to use, copy, modify,
merge and publish copies of the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

The Software must be redistributed free of charge to third parties.
*/
/***************************************\
\			 HackTools Library			/
/			 By Absolution				\
\				Source					/
/		    Version 1.0.0.171			\
\										/
/		© Absolution 2003	- 2010		\
\	  http://www.game-deception.org		/
/***************************************/

#include "../Includes.h"

//========================================================================================
// Interpreter
//----------------------------------------------------------------------------------------
void aui::Interpreter::AddCommand( const std::string &commandName, const commandType_t command )
{
	commandList[ commandName ] = command;
}

//----------------------------------------------------------------------------------------
bool aui::Interpreter::Execute( const std::string &rawCommand )
{
	argumentDeque.clear();

	std::string::const_iterator cSartIter = rawCommand.begin();
	std::string::const_iterator cEndIter = rawCommand.end();
	std::tr1::regex pattern( "(\")(.+?)\\1|(\\S+)" );

	std::tr1::smatch res;
	while( regex_search( cSartIter, cEndIter, res, pattern ) )
	{
		if( res[2].matched )
		{
			argumentDeque.push_back( res[2].str() );
			cSartIter = res[2].second;
			++cSartIter;
		}
		else if( res[3].matched )
		{
			argumentDeque.push_back( res[3].str() );
			cSartIter = res[3].second;
		}
		else
			break;
	}
	if( !argumentDeque.empty() )
	{
		return ExecuteCommand();
	}
	return false;
}

//----------------------------------------------------------------------------------------
bool aui::Interpreter::ExecuteCommand() const
{
	commandList_t::const_iterator cCommandIter = commandList.find( argumentDeque.at( COMMAND_POSITION ) );
	if( cCommandIter != commandList.end() )
	{
		cCommandIter->second();
		return true;
	}
	return false;
}

//----------------------------------------------------------------------------------------
size_t aui::Interpreter::ArgumentSize() const
{
	return argumentDeque.size();
}

//----------------------------------------------------------------------------------------
std::string aui::Interpreter::Argument( const std::size_t index ) const
{
	return argumentDeque.at( index );
}

Interpreter.h

namespace aui
{
	class Interpreter
	{
	public:
		enum { COMMAND_POSITION = 0 };
		typedef void ( *commandType_t )();
		typedef std::map< std::string, commandType_t > commandList_t;
		typedef std::deque< std::string > argumentDeque_t;

		void AddCommand( const std::string &commandName, const commandType_t command );

		bool Execute( const std::string &rawCommand );

		std::size_t ArgumentSize() const;	// argument size

		template< class T >
		void Argument( const std::size_t index, T &value ) const
		{
			std::istringstream buf( argumentDeque.at( index ) );

			buf >> value;

			if( buf.fail() )
			{

			}
		}

		template< class T, class Default >
		void ArgumentOrDefault( const std::size_t index, T &value, const Default &defaultValue ) const
		{
			try
			{
				std::istringstream buf( argumentDeque.at( index ) );

				buf >> value;

				if( buf.fail() )
				{

				}
			}
			catch ( std::out_of_range )
			{
				value = defaultValue;
			}
		}

		std::string Argument( const std::size_t index ) const;

	protected:
		bool ExecuteCommand() const;

		argumentDeque_t argumentDeque;
		commandList_t commandList;
	};
}

Functionality
This will function just like typing commands into a linux shell/windows cmd prompt. Quotes will group spaced characters/words together.

Example Program

Interpreter interpreter;

void test()
{
	cout << "blah" << endl;
	string test = interpreter.Argument( 1 );
	int i = 0;
	interpreter.Argument( 3, &i );
	interpreter.ArgumentOrDefault( 99, &i, 300 );
}

int _tmain(int argc, _TCHAR* argv[])
{

	interpreter.AddCommand( "test", &test );

	string command = "test BALLS BALS2 3 4 5 LOLOL \"hey thar\"";
	interpreter.Execute( command );

	while( true )
	{
		string keyIn;
		cin >> keyIn;
		interpreter.Execute( keyIn );
	}
	return 0;
}

C# Version

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Lab_4
{
    class Interpreter
    {
        // Interpreter - basically calls a function based on a string, arguments to the call are available to the function
        // via the instance of this class (argumentList)
        public const int COMMAND_POSITION = 0;

        public delegate void commandType_t();
        Dictionary<string, commandType_t> commandList = new Dictionary<string, commandType_t>();
        List<string> argumentList = new List<string>();

        public void AddCommand( string commandName, commandType_t command )
        {
	        commandList[commandName] = command;
        }

        public bool Execute( string rawCommand )
        {
            argumentList.Clear();

            const int quotesGroup = 2, nonQuotesGroup = 3;
            Regex regex = new Regex( "\\s+(\")(.+?)\\1|(\\S+)" );
            MatchCollection matches = regex.Matches( rawCommand );

            for( int i = 0; i != matches.Count; ++i )
            {
                Group QuotesGroup = matches[i].Groups[quotesGroup];
                Group NonQuotesGroup = matches[i].Groups[nonQuotesGroup];
                if( QuotesGroup.Success )
                    argumentList.Add( QuotesGroup.Value );
                else if( NonQuotesGroup.Success )
                    argumentList.Add( NonQuotesGroup.Value );
                else
                    break;
            }

            if( argumentList.Count != 0 )
	        {
		        return ExecuteCommand();
	        }
	        return false;
        }

        bool ExecuteCommand()
        {
	        commandType_t command = null;
            if( commandList.TryGetValue( argumentList[COMMAND_POSITION], out command ) )
            {
                command();
                return true;
            }
	        return false;
        }

        public int ArgumentSize()
        {
            return argumentList.Count;
        }

        public string Argument( int index )
        {
            return argumentList[index];
        }
    }
}

[Chazwazza]

You shouldn't define empty constructors/destructors/etc unless it's necessary. The compiler with generate one for you if you don't declare one so not only is it redundant it's confusing.

Also, if you're working in C++ you should avoid C style strings if you can in favour of the C++ solution (std::string).

I notice you use a string for execute but not addcommand. Oh btw, in your execute prototype:
bool Execute( const std::string rawCommand ) const; <-- Bad
bool Execute( const std::string& rawCommand ) const; <-- Good

You're not modifying the string so you should pass by reference-to-const. Most compilers should optimize out the temporary regardless but still, it's good practice. And oh, because the former is pass by value the const is redundant and confusing. It's an implementation detail not an interface detail.

Btw, what's with the lack of handling of the conversion failing in your Argument templates? Seems silly to have an empty block.

I personally use Lua as my command interpreter but still, thanks for the share.

P.S. You shouldn't declare global objects like that, it's not thread safe.

EDIT:

Just notice you're using "if (blah.size())". Just fyi "if (!blah.empty())" is potentially of higher performance and never of lower performance, so that's another one of those things you should just get into the habit of doing. Reason being is that for some containers it's difficult to know the size at any given time so it may need to be calculated every time the function is called. Not an issue in this particular case, but again, its a good habit to get into.

[Absolution]

You shouldn't define empty constructors/destructors/etc unless it's necessary. The compiler with generate one for you if you don't declare one so not only is it redundant it's confusing.

Also, if you're working in C++ you should avoid C style strings if you can in favour of the C++ solution (std::string).

I notice you use a string for execute but not addcommand. Oh btw, in your execute prototype:
bool Execute( const std::string rawCommand ) const; <-- Bad
bool Execute( const std::string& rawCommand ) const; <-- Good

You're not modifying the string so you should pass by reference-to-const. Most compilers should optimize out the temporary regardless but still, it's good practice. And oh, because the former is pass by value the const is redundant and confusing. It's an implementation detail not an interface detail.

Btw, what's with the lack of handling of the conversion failing in your Argument templates? Seems silly to have an empty block.

I personally use Lua as my command interpreter but still, thanks for the share.

P.S. You shouldn't declare global objects like that, it's not thread safe.

EDIT:

Just notice you're using "if (blah.size())". Just fyi "if (!blah.empty())" is potentially of higher performance and never of lower performance, so that's another one of those things you should just get into the habit of doing. Reason being is that for some containers it's difficult to know the size at any given time so it may need to be calculated every time the function is called. Not an issue in this particular case, but again, its a good habit to get into.

Thanks for the input. The constructors were in there and had a use at some point and I just never took them out - removed.

As for the failure handling, I decided to leave that out on purpose because I figured everyone would want to handle it a bit differently. It is there for more of a placeholder.

Yup, globals are bad news - I don't have them in my actual implementation :p.

As for the c-style strings, I figured that no one would/should ever try to add some sort of command who's name is refferenced from any type of string object but would rather just be in quotes. I just assumed it'd be faster using c-style strings than creating an std::string object on the stack and passing it by refference. Is that not the case?

Good call on the if( blah.size() ) and Interpreter::Execute( const std::string &rawCommand ) - changed.


Thanks for the feedback.

[syntroniks]

I just assumed it'd be faster using c-style strings than creating an std::string object on the stack and passing it by reference.

Passing a c-string by reference will be the fastest you can ever get.



...But in perspective, it won't matter.

[Chazwazza]

Thanks for the input. The constructors were in there and had a use at some point and I just never took them out - removed.

As for the failure handling, I decided to leave that out on purpose because I figured everyone would want to handle it a bit differently. It is there for more of a placeholder.

Yup, globals are bad news - I don't have them in my actual implementation :p.

As for the c-style strings, I figured that no one would/should ever try to add some sort of command who's name is refferenced from any type of string object but would rather just be in quotes. I just assumed it'd be faster using c-style strings than creating an std::string object on the stack and passing it by refference. Is that not the case?

Good call on the if( blah.size() ) and Interpreter::Execute( const std::string &rawCommand ) - changed.


Thanks for the feedback.

Your map uses a C++ string, you're taking a C style string in your function.

What that means is that a new string needs to be constructed to fill the key in the map.

If you were to have your function take an std::string as reference-to-const then the copy constructor would be called instead of the regular constructor. For certain implementations this can be a faster operation. Not to mention the fact that you're already dealing with STL strings so why force your users to do conversions unnecessarily.

I know what you mean (i.e. use of a string literal), but in that particular case the overhead is null because a string object needs to be constructed for the map anyway. No unnecessary temporary is created due to the use of a reference, so I can't really see a downside to using an STL string in that functions parameters.



EDIT:

On the note of references, why are your templates taking the value to modify by pointer rather than reference? As I say below, there's no such thing as a null-reference, and that argument should never be null, so a reference makes more sense, and is also safer.

Passing a c-string by reference will be the fastest you can ever get.



...But in perspective, it won't matter.

References are not pointers, and pointers are not references.

Just wanted to make that clear.

How they are IMPLEMENTED is something entirely different, but as far as the language goes there is a distinct difference. A reference IS THE OBJECT. It's not a 'pointer' to it. Also, there is no such thing as a 'null-reference', so they are quite different.

[Absolution]

Your map uses a C++ string, you're taking a C style string in your function.

What that means is that a new string needs to be constructed to fill the key in the map.

Ya, I actually just realized that before your post.


And the pointers in the argument functions, ya - again, good suggestion. Reason they are pointers is because the code is a year old and at the time, I [poorly] just threw pointers at everything. Fixed.


The main reason I actually posted it was to get some feedback, so thank you

[xen]

Handy bit of code, useful for anything that needs a console interface. Script interpreters for the win though

[syntroniks]

References are not pointers, and pointers are not references.

Gah, sorry for my terminology, I meant to say Functionforstring( &string );
Passing the address of the index of the string. I'm just used to C

[P47R!CK]

nice work... as always

[Xeno123]

Danke. I suck at regex, so this is nice.