Navigation

Changeset 618

Timestamp:

07/30/08 13:38:03 (4 months ago)

Author:

weyrick

Message:

more work on functions and extensions

Files:

r616	r618
5	5	#include <boost/program_options.hpp>
6	6	#include "pDriver.h"
	7	#include "pRuntime.h"
7	8
8	9	namespace po = boost::program_options;
…	…
11	12	{
12	13
	14	rphp::pRuntimeEngine runtime;
13	15	rphp::pDriver driver;
14	16
…	…
33	35	return 1;
34	36	}
35
	37
36	38	//std::cout << "Roadsend PHP" << std::endl;
37	39
…	…
42	44
43	45	//std::cout << "Optimization level is " << opt << "\n";
44
	46
45	47	}

r617	r618
20	20	#define PEXTENSIONBASE_H_
21	21
	22	#include <string>
	23	#include "pFunctionManager.h"
	24
22	25	namespace rphp {
23	26
…	…
27	30
28	31	protected:
	32	std::string extName;
29	33	pRuntimeEngine* runtime;
30	34
	35	void registerBuiltin(std::string name, pFunPointer1 f);
	36
31	37	public:
32		pExtBase(pRuntimeEngine *r~~) : runtime(r~~) { }
	38	pExtBase(pRuntimeEngine *r, std::string eName) : runtime(r), extName(eName) { }
33	39
34	40	virtual void extensionStartup() = 0;

r617	r618
20	20	#define RPHP_PFUNCTIONMANAGER
21	21
	22	#include <string>
	23	#include "pFunctionSig.h"
	24
22	25	namespace rphp {
23
24		~~class pRuntimeEngine;~~
25	26
26	27	class pFunctionManager {
27	28
	29
28	30	private:
29		~~pRuntimeEngine* runtime;~~
30	31
31	32	public:
32		pFunctionManager(pRuntimeEngine *r) : runtime(r) { }
	33
	34	//pFunctionManager(pRuntimeEngine *r) : runtime(r) { }
	35
	36	void registerBuiltin(std::string name, pFunPointer1 f);
33	37
34	38	};

r600	r618
106	106	var = (pInt)h->getSize();
107	107	}
108
	108
109	109	void operator()(pObjectP &h) const {
110	110	var = (pInt)h->getNumProperties();
…	…
118	118	};
119	119
	120	// a visitor for converting to a string
	121	class convertToBString : public boost::static_visitor<void> {
	122	protected:
	123	pVar &var;
	124
	125	public:
	126	convertToBString(pVar &v) : var(v) { }
	127
	128	void operator()(pTriState &h) const {
	129	(h) ? var = pBString("1") : var = pBString("0");
	130	}
	131
	132	void operator()(pInt &a) const {
	133	// TODO: real conversion
	134	var = pBString("some pInt");
	135	}
	136
	137	void operator()(pFloat &i) const {
	138	// TODO: real conversion
	139	var = pBString("some pFloat");
	140	}
	141
	142	void operator()(pBString &a) const {
	143	// nothing
	144	}
	145
	146	void operator()(pUStringP &a) const {
	147	// TODO
	148	}
	149
	150	void operator()(pHashP &h) const {
	151	var = pBString("array");
	152	}
	153
	154	void operator()(pObjectP &h) const {
	155	// TODO: toString
	156	var = pBString("object");
	157	}
	158
	159	void operator()(pVarRef &r) const {
	160	// TODO
	161	// unbox
	162	//boost::apply_visitor(convertToNumber(r), r);
	163	}
	164
	165	};
120	166
121	167	/*
…	…
143	189	return boost::get<pInt>(p);
144	190	}
145
	191
146	192	inline pBString pVar_getVal_pBString(const pVar &p) {
147	193	return boost::get<pBString>(p);
148	194	}
149
	195
150	196	inline pUStringP pVar_getVal_pUString(const pVar &p) {
151	197	return boost::get<pUStringP>(p);
…	…
161	207	*/
162	208	pVar pVar_castToNumber(const pVar p);
	209	pVar pVar_castToBString(const pVar p);
	210
163	211	pVar pVar_add(const pVar lhs, const pVar rhs);
164	212

r593	r618
47	47	typedef double pFloat;
48	48
	49	// note, pUInt is not a base PHP type (all PHP numbers are signed)
	50	typedef unsigned long pUInt;
	51
49	52	// string types: binary and unicode flavor
50	53	// "binary" strings

r617	r618
18	18
19	19	#include "pExtBase.h"
	20	#include "pRuntime.h"
20	21
21	22	namespace rphp {
22	23
	24	void pExtBase::registerBuiltin(std::string name, pFunPointer1 f) {
23	25
	26	runtime->functionManager->registerBuiltin(name, f);
24	27
25	28	}
	29
	30	}

r617	r618
22	22	namespace rphp {
23	23
	24	void pFunctionManager::registerBuiltin(std::string name, pFunPointer1 f) {
	25
	26	std::cout << "registering " << name << std::endl;
24	27
25	28	}
26	29
27	30
	31	}
	32
	33

r617	r618
25	25
26	26	pRuntimeEngine::pRuntimeEngine() : extManager(new pExtManager(this)),
27		functionManager(new pFunctionManager(~~this~~))
	27	functionManager(new pFunctionManager())
28	28	{
29	29	// runtime initialization
30	30
31	31	// load standard extension
32
	32
33	33	}
34	34
35	35
36	36	pRuntimeEngine::~pRuntimeEngine() {
37		// runtime shutdown
	37	// runtime shutdown
38	38	delete functionManager;
39	39	delete extManager;

r600	r618
23	23	// non destructive cast (explicit copy)
24	24	pVar pVar_castToNumber(const pVar p) {
25
26	25	pVar r = p;
27	26	boost::apply_visitor(convertToNumber(r), r);
28	27	return r;
	28	}
29	29
	30	// non destructive cast (explicit copy)
	31	pVar pVar_castToBString(const pVar p) {
	32	pVar r = p;
	33	boost::apply_visitor(convertToBString(r), r);
	34	return r;
30	35	}
31	36

r617	r618
26	26	std::cout << "initializing standard extension" << std::endl;
27	27
	28	registerBuiltin("strlen", boost::bind(&pStandardExt::strlen, this, _1));
	29
28	30	}
29	31
…	…
34	36	}
35	37
	38	/* Library Implementation */
	39
	40	pVar pStandardExt::strlen(pVar str) {
	41	pVar_castToBString(str);
	42	return (pInt)pVar_getVal_pBString(str).length();
	43	}
36	44
37	45	}

r617	r618
20	20	#define PSTANDARDEXT_H_
21	21
	22	#include "pTypes.h"
22	23	#include "pExtBase.h"
	24
	25	#define STD_EXT_NAME "standard"
23	26
24	27	namespace rphp {
…	…
28	31	public:
29	32
30		pStandardExt(pRuntimeEngine *r) : pExtBase(r) { }
	33	pStandardExt(pRuntimeEngine *r) : pExtBase(r, STD_EXT_NAME) { }
31	34
32	35	void extensionStartup();
33	36	void extensionShutdown();
	37
	38	pVar strlen(pVar str);
34	39
35	40	};