haiku.git

/*
 * Copyright 2005, Ingo Weinhold, bonefish@users.sf.net.
 * Distributed under the terms of the MIT License.
 */
#ifndef STRACE_SYSCALL_H
#define STRACE_SYSCALL_H

#include <string>
#include <vector>

#include <SupportDefs.h>

#include "TypeHandler.h"

using std::string;
using std::vector;

// Type
class Type {
public:
	Type(string typeName, TypeHandler *handler)
		: fTypeName(typeName), fHandler(handler), fCount(1) {}

	const string &TypeName() const	{ return fTypeName; }

	void SetHandler(TypeHandler *handler)
	{
		delete fHandler;
		fHandler = handler;
	}

	TypeHandler	*Handler() const	{ return fHandler; }

	uint32 Count() const			{ return fCount; }
	void SetCount(uint32 count)		{ fCount = count; }

private:
	string		fTypeName;
	TypeHandler	*fHandler;
	uint32		fCount;
};

// Parameter
class Parameter : public Type {
public:
	Parameter(string name, int32 offset, string typeName, TypeHandler *handler)
		: Type(typeName, handler),
		  fName(name),
		  fOffset(offset),
		  fInOut(false),
		  fOut(false)
	{
	}

	const string &Name() const		{ return fName; }
	int32 Offset() const			{ return fOffset; }
	bool InOut() const				{ return fInOut; }
	void SetInOut(bool inout)		{ fInOut = inout; }
	bool Out() const				{ return fOut; }
	void SetOut(bool out)			{ fOut = out; }

private:
	string	fName;
	int32	fOffset;
	bool	fInOut;
	bool	fOut;
};

// Syscall
class Syscall {
public:
	Syscall(string name, string returnTypeName, TypeHandler *returnTypeHandler)
		: fName(name),
		  fReturnType(new Type(returnTypeName, returnTypeHandler)),
		  fTracingEnabled(false)
	{
	}

	const string &Name() const
	{
		return fName;
	}

	Type *ReturnType() const
	{
		return fReturnType;
	}

	void AddParameter(Parameter *parameter)
	{
		fParameters.push_back(parameter);
	}

	void AddParameter(string name, int32 offset, string typeName,
		TypeHandler *handler)
	{
		AddParameter(new Parameter(name, offset, typeName, handler));
	}

	int32 CountParameters() const
	{
		return fParameters.size();
	}

	Parameter *ParameterAt(int32 index) const
	{
		return fParameters[index];
	}

	Parameter *GetParameter(string name) const
	{
		int32 count = CountParameters();
		for (int32 i = 0; i < count; i++) {
			Parameter *parameter = ParameterAt(i);
			if (parameter->Name() == name)
				return parameter;
		}

		return NULL;
	}

	bool TracingEnabled() const
	{
		return fTracingEnabled;
	}

	void EnableTracing(bool enable)
	{
		fTracingEnabled = enable;
	}

private:
	string				fName;
	Type				*fReturnType;
	vector<Parameter*>	fParameters;
	bool				fTracingEnabled;
};

#endif	// STRACE_SYSCALL_H