You're probably recursively include or require-ing the definitions. Have did you set an autoloader? Do you know how they work, because you might want to create a file for each class definition (ASAP).
Consider this:
//index.php
include('someFile.php');
include('xx.class.php');
//someFile:
include('xx.class.php');//ERROR
//or even worse, in xx.Class.php:
include('someFile.php');//includes file that includes this file, which will include someFile again, which includes this file, which...
To avoid this, use include_once or require_once. This avoids your including the same file twice.
As to what causes the order of the errors:
The main reason why you get the error "cannot redeclare function" before you get the error cannot redeclare class is, I think, simply because of how PHP compiles the code.
PHP doesn't leave your code as is anymore. Your code is compiled to bytecode, so it's... shall we say... changed quite a bit in the process
functions just have to be parsed before PHP can move on to parsing the classes. Why? that's quite simply because PHP class methods are, essentially, functions, too.
They're called using the zend_object_handlers pointer, when calling a method, the zval is passed, allong with the zend_class_entry, in order for the zend_function to have access to all the data in scope (all the object properties and methods and what have you). I don't know how your C knowledge is, but if you want to test it:
ZEND_API zval* zend_call_method(
zval **object_pp,
zend_class_entry *obj_ce,
zend_function **fn_proxy,
const char *function_name,
int function_name_len,
zval **retval_ptr_ptr,
int param_count,
zval* arg1,
zval* arg2 TSRMLS_DC
) {
int result;
zend_fcall_info fci;
zval z_fname;
zval *retval;
HashTable *function_table;
zval **params[2];
params[0] = &arg1;
params[1] = &arg2;
fci.size = sizeof(fci);
/* fci.function_table = NULL;
* will be read form zend_class_entry of object if needed
*/
fci.object_ptr = object_pp ? *object_pp : NULL;
fci.function_name = &z_fname;
fci.retval_ptr_ptr = retval_ptr_ptr ? retval_ptr_ptr : &retval;
fci.param_count = param_count;
fci.params = params;
fci.no_separation = 1;
fci.symbol_table = NULL;
if (!fn_proxy && !obj_ce) {
/* no interest in caching and no information
* already present that is needed later inside
* zend_call_function.
*/
ZVAL_STRINGL(&z_fname, function_name, function_name_len, 0);
fci.function_table = !object_pp ? EG(function_table) : NULL;
result = zend_call_function(&fci, NULL TSRMLS_CC);
} else {
zend_fcall_info_cache fcic;
fcic.initialized = 1;
if (!obj_ce) {
obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL;
}
if (obj_ce) {
function_table = &obj_ce->function_table;
} else {
function_table = EG(function_table);
}
if (!fn_proxy || !*fn_proxy) {
if (zend_hash_find(
function_table, function_name,
function_name_len+1,
(void **) &fcic.function_handler) == FAILURE
) {
/* error at c-level */
zend_error(
E_CORE_ERROR,
"Couldn't find implementation for method %s%s%s",
obj_ce ? obj_ce->name : "",
obj_ce ? "::" : "", function_name
);
}
if (fn_proxy) {
*fn_proxy = fcic.function_handler;
}
} else {
fcic.function_handler = *fn_proxy;
}
fcic.calling_scope = obj_ce;
if (object_pp) {
fcic.called_scope = Z_OBJCE_PP(object_pp);
} else if (obj_ce &&
!(EG(called_scope) &&
instanceof_function(EG(called_scope), obj_ce TSRMLS_CC))) {
fcic.called_scope = obj_ce;
} else {
fcic.called_scope = EG(called_scope);
}
fcic.object_ptr = object_pp ? *object_pp : NULL;
result = zend_call_function(&fci, &fcic TSRMLS_CC);
}
if (result == FAILURE) {
/* error at c-level */
if (!obj_ce) {
obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL;
}
if (!EG(exception)) {
zend_error(
E_CORE_ERROR,
"Couldn't execute method %s%s%s",
obj_ce ? obj_ce->name : "",
obj_ce ? "::" : "", function_name
);
}
}
if (!retval_ptr_ptr) {
if (retval) {
zval_ptr_dtor(&retval);
}
return NULL;
}
return *retval_ptr_ptr;
}
As you can see here, in order for a method to be callable, all zend_function's must be defined. Since a constructor is a function, too, I suspect all the functions in your xx.Class.php file are parsed. Since the methods are defined within their own (class) scope, there can't be a name conflict (unless there are duplicate methods), before the zend_object is actually registered.
Besides, any decent bit of OO code registers an autoloader function. What would an object be if the parser didn't know what to make of that function keyword?
There's a lot more too it than just that, but I figure that must be why PHP notices why you're attemting to redefine a function before it notices you're redifining a class.
A couple of useful links, containing a more detailed description of how the zend engine works with functions/methods can be found here
It's always useful to keep a tab with the actual source at hand, too, so you can actually see the code they're talking about
