1/*
2 * Copyright 2005-2007, Haiku Inc. All rights reserved.
3 * Distributed under the terms of the MIT License.
4 *
5 * Authors:
6 * 		Ingo Weinhold <bonefish@cs.tu-berlin.de>
7 * 		Hugo Santos <hugosantos@gmail.com>
8 */
9#ifndef STRACE_TYPE_HANDLER_H
10#define STRACE_TYPE_HANDLER_H
11
12#include <string>
13#include <map>
14
15#include <arch_config.h>
16#include <SupportDefs.h>
17
18using std::string;
19
20class Context;
21class Parameter;
22class MemoryReader;
23
24typedef FUNCTION_CALL_PARAMETER_ALIGNMENT_TYPE align_t;
25
26// TypeHandler
27class TypeHandler {
28public:
29	TypeHandler() {}
30	virtual ~TypeHandler() {}
31
32	virtual string GetParameterValue(Context &, Parameter *,
33					 const void *value) = 0;
34	virtual string GetReturnValue(Context &, uint64 value) = 0;
35};
36
37class EnumTypeHandler : public TypeHandler {
38public:
39	typedef std::map<int, const char *> EnumMap;
40
41	EnumTypeHandler(const EnumMap &);
42
43	string GetParameterValue(Context &c, Parameter *, const void *);
44	string GetReturnValue(Context &, uint64 value);
45
46private:
47	string RenderValue(Context &, unsigned int value) const;
48
49	const EnumMap &fMap;
50};
51
52// currently limited to select ints
53class TypeHandlerSelector : public TypeHandler {
54public:
55	typedef std::map<int, TypeHandler *> SelectMap;
56
57	TypeHandlerSelector(const SelectMap &, int sibling,
58			    TypeHandler *def);
59
60	string GetParameterValue(Context &, Parameter *, const void *);
61	string GetReturnValue(Context &, uint64 value);
62
63private:
64	const SelectMap &fMap;
65	int fSibling;
66	TypeHandler *fDefault;
67};
68
69// templatized TypeHandler factory class
70// (I tried a simple function first, but then the compiler complains for
71// the partial instantiation. Not sure, if I'm missing something or this is
72// a compiler bug).
73template<typename Type>
74struct TypeHandlerFactory {
75	static TypeHandler *Create();
76};
77
78extern TypeHandler *create_pointer_type_handler();
79extern TypeHandler *create_string_type_handler();
80
81// specialization for "const char*"
82template<>
83struct TypeHandlerFactory<const char*> {
84	static inline TypeHandler *Create()
85	{
86		return create_string_type_handler();
87	}
88};
89
90#define DEFINE_FACTORY(name, type) \
91	template<> \
92	struct TypeHandlerFactory<type> { \
93		static inline TypeHandler *Create() \
94		{ \
95			extern TypeHandler *create_##name##_type_handler(); \
96			return create_##name##_type_handler(); \
97		} \
98	} \
99
100struct fd_set;
101struct ifconf;
102struct ifreq;
103struct message_args;
104struct sockaddr_args;
105struct socket_args;
106struct sockopt_args;
107
108DEFINE_FACTORY(fdset_ptr, fd_set *);
109DEFINE_FACTORY(ifconf_ptr, ifconf *);
110DEFINE_FACTORY(ifreq_ptr, ifreq *);
111DEFINE_FACTORY(message_args_ptr, message_args *);
112DEFINE_FACTORY(sockaddr_args_ptr, sockaddr_args *);
113DEFINE_FACTORY(socket_args_ptr, socket_args *);
114DEFINE_FACTORY(sockopt_args_ptr, sockopt_args *);
115
116DEFINE_FACTORY(int_ptr, int *);
117DEFINE_FACTORY(long_ptr, long *);
118DEFINE_FACTORY(longlong_ptr, long long *);
119DEFINE_FACTORY(uint_ptr, unsigned int *);
120DEFINE_FACTORY(ulong_ptr, unsigned long *);
121DEFINE_FACTORY(ulonglong_ptr, unsigned long long *);
122
123// partial specialization for generic pointers
124template<typename Type>
125struct TypeHandlerFactory<Type*> {
126	static inline TypeHandler *Create()
127	{
128		return create_pointer_type_handler();
129	}
130};
131
132template<typename Type>
133class TypeHandlerImpl : public TypeHandler {
134public:
135	string GetParameterValue(Context &, Parameter *, const void *);
136	string GetReturnValue(Context &, uint64 value);
137};
138
139#endif	// STRACE_TYPE_HANDLER_H
140