cvsroot/libcpjit/cpjit.h.PL

#!/usr/bin/perl

# create cpjit.h

open STDOUT, ">cpjit.h"
  or die "cpijit.h: $!";

$CPJIT_MAX_ARGS = 9;

print <<EOF;
#line 12 "cpjit.h.PL"
/*
    This file is AUTOMAGICALLY created by cpjit.h.PL. Modifications will
    be lost.

    cpjit.h -- c portable jit in time compiler
    Copyright (C) 2005      Marc Lehmann <cpjit\@schmorp.de>
 
    This file is part of libcpjit.

    libcpjit is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with gvpe; if not, write to the Free Software
    Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <string>
#include <sstream>
#include <inttypes.h>

namespace cpjit
{

#define CPJIT_MAX_ARGS $CPJIT_MAX_ARGS
#define CPJIT_NULLID ""

typedef std::string idstr;

// environment for persistent or temporary storage
struct env
{
  std::string path;
  bool temporary;
  int idxfd;
  unsigned long nextid;

  void dolock (bool lock);
  void lock ();
  void unlock ();

  void load_index ();
  void save_index ();

public:
  env (const std::string &path = CPJIT_NULLID, bool temporary = true);
  ~env ();

  std::string genid ();
};

struct fun
{
  env &e;
  idstr id;
  std::string source;
  void *funptr;

  fun (env &e, const idstr &id);

  // is compiled function available?
  bool compiled ()
  {
    return funptr;
  }

  void set_source (const std::string source);

  // returns the function pointer
  void *ptr ();
};

struct funbuild : std::ostringstream
{
  env &e;
  idstr id;
  std::string hdr;

  funbuild (env &e, const idstr &id, const char *rettype, ...);
  std::string finish ();

  fun *get ()
  {
    fun *f = new fun (e, id);
    f->set_source (finish ());
    return f;
  }
};

typedef unsigned char U8;
typedef   signed char I8;
typedef uint16_t      U16;
typedef  int16_t      I16;
typedef uint32_t      U32;
typedef  int32_t      I32;
typedef uint64_t      U64;
typedef  int64_t      I64;
typedef float         FLT;
typedef double        DBL;
typedef void *        PTR;

template<typename T> struct typestr { };

template<> struct typestr<U8   > { static const char str[]; };
template<> struct typestr<U16  > { static const char str[]; };
template<> struct typestr<U32  > { static const char str[]; };
template<> struct typestr<U64  > { static const char str[]; };
template<> struct typestr<I8   > { static const char str[]; };
template<> struct typestr<I16  > { static const char str[]; };
template<> struct typestr<I32  > { static const char str[]; };
template<> struct typestr<I64  > { static const char str[]; };
template<> struct typestr<FLT  > { static const char str[]; };
template<> struct typestr<DBL  > { static const char str[]; };
template<> struct typestr<PTR  > { static const char str[]; };
template<> struct typestr<U8  *> { static const char str[]; };
template<> struct typestr<U16 *> { static const char str[]; };
template<> struct typestr<U32 *> { static const char str[]; };
template<> struct typestr<U64 *> { static const char str[]; };
template<> struct typestr<I8  *> { static const char str[]; };
template<> struct typestr<I16 *> { static const char str[]; };
template<> struct typestr<I32 *> { static const char str[]; };
template<> struct typestr<I64 *> { static const char str[]; };
template<> struct typestr<FLT *> { static const char str[]; };
template<> struct typestr<DBL *> { static const char str[]; };

EOF

for (0 .. $CPJIT_MAX_ARGS) {
  print <<EOF;
#line 143 "cpjit.h.PL"

template<typename R${\( join "", map ", typename A$_", 1..$_ )}>
struct fun$_ : fun
{
  fun$_ (env &e, const idstr &id)
  : fun (e, id)
  {
  }

  int operator ()(${\( join ", ", map "A$_ a$_", 1..$_ )})
  {
    return ((R (*)(${\( join ", ", map "A$_", 1..$_ )})) ptr ())(${\( join ", ", map "a$_", 1..$_ )});
  }
};

template<typename R${\( join "", map ", typename A$_", 1..$_ )}>
struct funbuild$_ : funbuild
{
  funbuild$_ (env &e, const idstr &id = CPJIT_NULLID)
  : funbuild (e, id, typestr<R>::str${\( join "", map ", typestr<A$_>::str", 1..$_ )}, (const char *)0)
  {
  }

  fun$_<R${\( join "", map ", A$_", 1..$_ )}> *get ()
  {
    fun$_<R${\( join "", map ", A$_", 1..$_ )}> *f = new fun$_<R${\( join "", map ", A$_", 1..$_ )}> (e, id);
    f->set_source (finish ());
    return f;
  }
};

EOF
}

print <<EOF;
}
EOF

Revision:	1.10
Committed:	Fri Oct 14 00:21:57 2005 UTC (21 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+10 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	#!/usr/bin/perl
2
3			# create cpjit.h
4
5			open STDOUT, ">cpjit.h"
6			or die "cpijit.h: $!";
7
8	root	1.6	$CPJIT_MAX_ARGS = 9;
9
10	root	1.1	print <<EOF;
11	root	1.6	#line 12 "cpjit.h.PL"
12	root	1.1	/*
13	root	1.2	This file is AUTOMAGICALLY created by cpjit.h.PL. Modifications will
14			be lost.
15
16	root	1.1	cpjit.h -- c portable jit in time compiler
17	root	1.8	Copyright (C) 2005 Marc Lehmann <cpjit\@schmorp.de>
18	root	1.1
19			This file is part of libcpjit.
20
21			libcpjit is free software; you can redistribute it and/or modify
22			it under the terms of the GNU General Public License as published by
23			the Free Software Foundation; either version 2 of the License, or
24			(at your option) any later version.
25
26			This program is distributed in the hope that it will be useful,
27			but WITHOUT ANY WARRANTY; without even the implied warranty of
28			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29			GNU General Public License for more details.
30
31			You should have received a copy of the GNU General Public License
32			along with gvpe; if not, write to the Free Software
33			Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34			*/
35
36	root	1.3	#include <string>
37	root	1.6	#include <sstream>
38	root	1.4	#include <inttypes.h>
39	root	1.3
40	root	1.1	namespace cpjit
41			{
42
43	root	1.6	#define CPJIT_MAX_ARGS $CPJIT_MAX_ARGS
44			#define CPJIT_NULLID ""
45
46	root	1.5	typedef std::string idstr;
47	root	1.3
48	root	1.5	// environment for persistent or temporary storage
49			struct env
50			{
51	root	1.7	std::string path;
52			bool temporary;
53	root	1.10	int idxfd;
54	root	1.7	unsigned long nextid;
55
56	root	1.10	void dolock (bool lock);
57			void lock ();
58			void unlock ();
59
60			void load_index ();
61			void save_index ();
62
63			public:
64	root	1.7	env (const std::string &path = CPJIT_NULLID, bool temporary = true);
65			~env ();
66	root	1.10
67	root	1.7	std::string genid ();
68	root	1.5	};
69
70	root	1.6	struct fun
71	root	1.5	{
72			env &e;
73			idstr id;
74	root	1.6	std::string source;
75	root	1.7	void *funptr;
76	root	1.6
77			fun (env &e, const idstr &id);
78	root	1.5
79	root	1.6	// is compiled function available?
80	root	1.7	bool compiled ()
81			{
82			return funptr;
83			}
84	root	1.6
85	root	1.8	void set_source (const std::string source);
86	root	1.5
87	root	1.7	// returns the function pointer
88	root	1.5	void *ptr ();
89			};
90
91	root	1.6	struct funbuild : std::ostringstream
92	root	1.5	{
93	root	1.6	env &e;
94			idstr id;
95	root	1.8	std::string hdr;
96	root	1.6
97			funbuild (env &e, const idstr &id, const char *rettype, ...);
98	root	1.8	std::string finish ();
99	root	1.6
100			fun *get ()
101			{
102			fun *f = new fun (e, id);
103	root	1.8	f->set_source (finish ());
104	root	1.6	return f;
105			}
106	root	1.5	};
107	root	1.2
108	root	1.5	typedef unsigned char U8;
109			typedef signed char I8;
110			typedef uint16_t U16;
111			typedef int16_t I16;
112			typedef uint32_t U32;
113			typedef int32_t I32;
114			typedef uint64_t U64;
115			typedef int64_t I64;
116	root	1.9	typedef float FLT;
117			typedef double DBL;
118	root	1.7	typedef void * PTR;
119	root	1.5
120			template<typename T> struct typestr { };
121
122			template<> struct typestr<U8 > { static const char str[]; };
123			template<> struct typestr<U16 > { static const char str[]; };
124			template<> struct typestr<U32 > { static const char str[]; };
125			template<> struct typestr<U64 > { static const char str[]; };
126			template<> struct typestr<I8 > { static const char str[]; };
127			template<> struct typestr<I16 > { static const char str[]; };
128			template<> struct typestr<I32 > { static const char str[]; };
129			template<> struct typestr<I64 > { static const char str[]; };
130	root	1.9	template<> struct typestr<FLT > { static const char str[]; };
131			template<> struct typestr<DBL > { static const char str[]; };
132	root	1.7	template<> struct typestr<PTR > { static const char str[]; };
133	root	1.5	template<> struct typestr<U8 *> { static const char str[]; };
134			template<> struct typestr<U16 *> { static const char str[]; };
135			template<> struct typestr<U32 *> { static const char str[]; };
136			template<> struct typestr<U64 *> { static const char str[]; };
137			template<> struct typestr<I8 *> { static const char str[]; };
138			template<> struct typestr<I16 *> { static const char str[]; };
139			template<> struct typestr<I32 *> { static const char str[]; };
140			template<> struct typestr<I64 *> { static const char str[]; };
141	root	1.9	template<> struct typestr<FLT *> { static const char str[]; };
142			template<> struct typestr<DBL *> { static const char str[]; };
143	root	1.2
144	root	1.6	EOF
145
146			for (0 .. $CPJIT_MAX_ARGS) {
147			print <<EOF;
148	root	1.7	#line 143 "cpjit.h.PL"
149	root	1.6
150			template<typename R${\( join "", map ", typename A$_", 1..$_ )}>
151			struct fun$_ : fun
152			{
153	root	1.7	fun$_ (env &e, const idstr &id)
154	root	1.6	: fun (e, id)
155			{
156			}
157
158			int operator ()(${\( join ", ", map "A$_ a$_", 1..$_ )})
159			{
160			return ((R (*)(${\( join ", ", map "A$_", 1..$_ )})) ptr ())(${\( join ", ", map "a$_", 1..$_ )});
161			}
162			};
163
164			template<typename R${\( join "", map ", typename A$_", 1..$_ )}>
165			struct funbuild$_ : funbuild
166	root	1.5	{
167	root	1.6	funbuild$_ (env &e, const idstr &id = CPJIT_NULLID)
168			: funbuild (e, id, typestr<R>::str${\( join "", map ", typestr<A$_>::str", 1..$_ )}, (const char *)0)
169	root	1.2	{
170	root	1.5	}
171	root	1.3
172	root	1.6	fun$_<R${\( join "", map ", A$_", 1..$_ )}> *get ()
173	root	1.2	{
174	root	1.6	fun$_<R${\( join "", map ", A$_", 1..$_ )}> *f = new fun$_<R${\( join "", map ", A$_", 1..$_ )}> (e, id);
175	root	1.8	f->set_source (finish ());
176	root	1.6	return f;
177	root	1.5	}
178			};
179	root	1.3
180	root	1.1	EOF
181	root	1.6	}
182	root	1.1
183			print <<EOF;
184			}
185			EOF
186