obj2ptr

来自「R 树」· 代码 · 共 1,106 行 · 第 1/2 页

#
# generate constructor stub
#

sub generateConstructorStub {
    print HANDLE "$ptrClass\n";
    print HANDLE "new_$ptrClass(";
    for($i=0; $i<@params; $i++) {
	print HANDLE ", " if ($i != 0);

	# remove default argument
	($param = $params[$i]) =~ s/\s*=.*$//;
	print HANDLE $param;
    }
    print HANDLE ")\n";
    print HANDLE "{\n";
    print HANDLE "	$objClass *_obj;\n";
    print HANDLE "	$ptrClass _ptr;\n";
    print HANDLE "\n";
    print HANDLE "	_obj = new $objClass(";
    for($i=0; $i<@variables; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $variables[$i];
    }
    print HANDLE ");\n";
    print HANDLE "\n";
    print HANDLE "	if(_obj->hasFailed())\n";
    print HANDLE "		return $ptrClass::null;\n";
    print HANDLE "\n";
    print HANDLE "	_ptr.assign(_obj);\n";
    print HANDLE "	return _ptr;\n";
    print HANDLE "}\n";
    print HANDLE "\n";
}

#
# generate equals stub
#

sub generateEqualsStub {
    if($returnType ne "HnBool") {
	die("$program: the return type of equals() must be HnBool, stopped");
    }
    if(@params != 1 || !($params[0] =~ /const $ptrClass &$variables[0]/)) {
	die("$program: the parameter type of equals() must be ".
	    "`const $ptrClass &', stopped");
    }
    print HANDLE <<"EOF";
HnBool
$ptrClass::equals(const $ptrClass &ptr) const {
	if(isInvalid()) {
		if(ptr.isInvalid())
			return HnTRUE;
		else
			return HnFALSE;
    	}
    	else {
		if(ptr.isInvalid())
			return HnFALSE;
		else
			return getObject()->equals(ptr);
	}
}

EOF
}

#
# generate toString stub
#

sub generateToStringStub {
    if($returnType ne "HnString") {
	die("$program: the return type of toString() must be HnString, ".
	    "stopped");
    }
    if(@params != 1 || !($params[0] eq "void")) {
	die("$program: the paramter of toString() must be `void', stopped");
    }
    print HANDLE <<"EOF";
HnString
$ptrClass::toString(void) const {
	if(isInvalid())
		return "$ptrClass::null";
    	else
		return getObject()->toString();
}

EOF
    ;
}

#
# generate normal stub
#

sub generateNormalStub {
    print HANDLE "$returnType\n";
    print HANDLE "$ptrClass::$methodName(";
    for($i=0; $i<@params; $i++) {
	print HANDLE ", " if ($i != 0);

	# remove default argument
	($param = $params[$i]) =~ s/\s*=.*$//;
	print HANDLE $param;
    }
    print HANDLE ")";
    print HANDLE " $qualifier" if ($qualifier);
    print HANDLE "\n";
    print HANDLE "{\n";
    if($returnType eq "void") {
	print HANDLE "	";
    }
    else {
	print HANDLE "	return ";
    }   
    print HANDLE "getObject()->$methodName(";
    for($i=0; $i<@variables; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $variables[$i];
    }
    print HANDLE ");\n";
    print HANDLE "}\n";
    print HANDLE "\n";
}

#
# generate operator stub
#

sub generateOperatorStub {
    if("$returnType" ne "") {
	print HANDLE "$returnType\n";
    }
    print HANDLE "$ptrClass::$methodName(";
    for($i=0; $i<@params; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $params[$i];
    }
    print HANDLE ")";
    print HANDLE " $qualifier" if ($qualifier);
    print HANDLE "\n";
    print HANDLE "{\n";
    if($returnType eq "void") {
	print HANDLE "	";
    }
    else {
	print HANDLE "	return ";
    }   
    print HANDLE "getObject()->$methodName(";
    for($i=0; $i<@variables; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $variables[$i];
    }
    print HANDLE ");\n";
    print HANDLE "}\n";
    print HANDLE "\n";
}

#
# generate class method stub
#

sub generateClassMethodStub {
    print HANDLE "$returnType\n";
    print HANDLE "$ptrClass::$methodName(";
    for($i=0; $i<@params; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $params[$i];
    }
    print HANDLE ")";
    print HANDLE " $qualifier" if ($qualifier);
    print HANDLE "\n";
    print HANDLE "{\n";
    if($returnType eq "void") {
	print HANDLE "	";
    }
    else {
	print HANDLE "	return ";
    }   
    print HANDLE "$objClass::$methodName(";
    for($i=0; $i<@variables; $i++) {
	print HANDLE ", " if ($i != 0);
	print HANDLE $variables[$i];
    }
    print HANDLE ");\n";
    print HANDLE "}\n";
    print HANDLE "\n";
}

#
# generate array
#

sub generateArray {
    print HANDLE <<"EOF";
/*
 * ${ptrClass}ArrayObj
 */

#include <stdlib.h>
EOF

    if($ptrClass ne "HnString") {
	print HANDLE '#include "HnString.hh"', "\n";
    }

    print HANDLE <<"EOF";
class ${ptrClass}ArrayObj: public HnObject {
private:
	$ptrClass **array;
	int len;
	int size;

	static const int initialSize;

	void initialize(void) {
		array = NULL;
		len = 0;
		size = 0;
	}
	void dispose(void) {
		if(array != NULL) {
			int i;
			for(i=0; i<len; i++)
				delete array[i];
			free(array);
		}
		array = NULL;
		len = 0;
		size = 0;
	}
	void ensureSize(int requiredSize);

public:
	/* constructor and destructor */
	${ptrClass}ArrayObj(void);
	${ptrClass}ArrayObj(const ${ptrClass}Array &ptr);
	~${ptrClass}ArrayObj(void);

	/* clear, append, insert, and remove */
	void clear(void);
	void append(const $ptrClass &ptr);
	void append(const ${ptrClass}Array &ptr);
	void insert(const $ptrClass &ptr, int index);
	$ptrClass remove(int index);
	void set(const $ptrClass &ptr, int index);
	void swap(int i, int j);

	/* length and get */
	int length(void) const { return len; }
	$ptrClass &get(int i) const;

	/* utilities */
	HnBool equals(const ${ptrClass}Array &ptr) const;
	int indexOf(const $ptrClass &ptr, int fromIndex) const;
	HnString toString(void) const;
};

const int ${ptrClass}ArrayObj::initialSize = 4;

static void *
xrealloc(void *ptr, size_t size)
{
        if(ptr == NULL) {
                if((ptr = malloc(size)) == NULL)
                        HnSysError("malloc");
        }
        else {
                if((ptr = realloc(ptr, size)) == NULL)
                        HnSysError("realloc");
        }

        return ptr;
}

void
${ptrClass}ArrayObj::ensureSize(int requiredSize)
{
	int oldSize, newSize;

	if((oldSize = size) >= requiredSize)
		return;

	if((newSize = oldSize) == 0)
		newSize = initialSize;

	while(newSize < requiredSize)
		newSize *= 2;

	array = ($ptrClass **)xrealloc(array, sizeof($ptrClass *) * newSize);

	size = newSize;
}

${ptrClass}ArrayObj::${ptrClass}ArrayObj(void)
{
	initialize();
}

${ptrClass}ArrayObj::${ptrClass}ArrayObj(const ${ptrClass}Array &ptr)
{
	initialize();

	clear();
	append(ptr);
}

${ptrClass}ArrayObj::~${ptrClass}ArrayObj(void)
{
	dispose();
}

void
${ptrClass}ArrayObj::clear(void)
{
	dispose();
}

void
${ptrClass}ArrayObj::append(const $ptrClass &ptr)
{
	ensureSize(len + 1);

	array[len] = new $ptrClass(ptr);
	len ++;
}

void
${ptrClass}ArrayObj::append(const ${ptrClass}Array &ptr)
{
	int i;

	ensureSize(len + ptr.length());

	for(i=0; i<ptr.length(); i++)
		append(ptr[i]);
}

void
${ptrClass}ArrayObj::insert(const $ptrClass &ptr, int index)
{
	if(index < 0 || index > len)
		HnAbort("${ptrClass}ArrayObj::insert: "
			"index is out of bounds.");

	ensureSize(len + 1);

	memmove(array + index + 1, array + index,
		sizeof($ptrClass *) * (len - index));

	array[index] = new $ptrClass(ptr);
	len ++;
}

$ptrClass
${ptrClass}ArrayObj::remove(int index)
{
	$ptrClass ptr = get(index);

	if(index < 0 || index >= len)
                HnAbort("${ptrClass}ArrayObj::remove: "
			"index is out of bounds.");

	delete array[index];

	memmove(array + index, array + index + 1,
		sizeof($ptrClass *) * (len - index - 1));
	len --;

	return ptr;
}

void
${ptrClass}ArrayObj::set(const $ptrClass &ptr, int index)
{
	if(index < 0 || index >= len)
		HnAbort("${ptrClass}ArrayObj::set: "
			"index is out of bounds.");

	delete array[index];

	array[index] = new $ptrClass(ptr);
}

void
${ptrClass}ArrayObj::swap(int i, int j)
{
	if(i < 0 || i >= len || j < 0 || j >= len)
		HnAbort("${ptrClass}ArrayObj::swap: index is out of bounds.");

	$ptrClass *ptr = array[i];
	array[i] = array[j];
	array[j] = ptr;
}

$ptrClass &
${ptrClass}ArrayObj::get(int i) const {
	if(i < 0 || i >= len)
		HnAbort("${ptrClass}ArrayObj::get: index is out of bounds.");

	return *array[i];
}

HnBool
${ptrClass}ArrayObj::equals(const ${ptrClass}Array &ptr) const {
	int i;

	if(len != ptr.length())
		return HnFALSE;

	for(i=0; i<len; i++) {
		if(!array[i]->equals(ptr[i]))
			return HnFALSE;
	}

	return HnTRUE;
}

int
${ptrClass}ArrayObj::indexOf(const $ptrClass &ptr, int fromIndex) const
{
	int i;

	for(i=fromIndex; i<len; i++) {
		if(array[i]->equals(ptr))
			return i;
	}

	return -1;
}

HnString
${ptrClass}ArrayObj::toString(void) const
{
	HnString string;

	string = "[ ";
	for(int i=0; i<len; i++) {
		if(i != 0)
			string += ", ";
		string += array[i]->toString();
	}
	string += " ]";

	return string;
}

/*
 * ${ptrClass}Array
 */

const ${ptrClass}Array ${ptrClass}Array::null;

${ptrClass}Array
new_${ptrClass}Array(void)
{
	${ptrClass}Array ptr;

        ptr.assign(new ${ptrClass}ArrayObj());
        return ptr;
}

${ptrClass}Array
new_${ptrClass}Array(const ${ptrClass}Array &value)
{
	${ptrClass}Array ptr;

        if(value.isInvalid())
                ptr.assign(NULL);
        else
                ptr.assign(new ${ptrClass}ArrayObj(value));

        return ptr;
}

void
${ptrClass}Array::clear(void)
{
	getObject()->clear();
}

void
${ptrClass}Array::append(const $ptrClass &ptr)
{
	getObject()->append(ptr);
}

void
${ptrClass}Array::append(const ${ptrClass}Array &ptr)
{
	getObject()->append(ptr);
}

void
${ptrClass}Array::insert(const $ptrClass &ptr, int index)
{
	getObject()->insert(ptr, index);
}

$ptrClass
${ptrClass}Array::remove(int index)
{
	return getObject()->remove(index);
}

void
${ptrClass}Array::set(const $ptrClass &ptr, int index)
{
	getObject()->set(ptr, index);
}

void
${ptrClass}Array::swap(int i, int j)
{
	getObject()->swap(i, j);
}

int
${ptrClass}Array::length(void) const
{
	return getObject()->length();
}

$ptrClass &
${ptrClass}Array::get(int i) const
{
	return getObject()->get(i);
}

HnBool
${ptrClass}Array::equals(const ${ptrClass}Array &ptr) const
{
	return getObject()->equals(ptr);
}

int
${ptrClass}Array::indexOf(const $ptrClass &ptr, int fromIndex) const
{
	return getObject()->indexOf(ptr, fromIndex);
}

HnString
${ptrClass}Array::toString(void) const
{
	return getObject()->toString();
}

EOF
    ;

}