Comments for Finite Hate Machine

Comment on I really don’t know what you mean by Owen Jacobson

Owen Jacobson — Tue, 02 Mar 2010 23:37:33 +0000

That’s probably a consequence of PHP’s “organic” development: array indexing has existed for most of PHP’s life, while the -> dereference operator was introduced in PHP 4, when the PHP community had started to grok the idea that expressions should be interchangable.

Comment on I really don’t know what you mean by seutje

seutje — Tue, 02 Mar 2010 12:20:29 +0000

what really intrigues me is that
function foo() { $bar = new stdClass(); $bar->baz = 'meh'; return $bar; } print foo()->baz; // prints 'meh'

seems to work fine

Comment on Did you think I wouldn’t recognize this compromise by Just when everything was making sense « Finite Hate Machine

Just when everything was making sense « Finite Hate Machine — Thu, 21 Jan 2010 00:06:42 +0000

[...] Finite Hate Machine PHP is not my favourite language. « Did you think I wouldn’t recognize this compromise [...]

Comment on I decided I was never coming down by Taavi

Taavi — Tue, 19 Jan 2010 19:44:30 +0000

Unfortunately gdb doesn’t help either, because it just dies in the guts of PHP. Been there, done that, see the dev blog post. :(

Comment on My purity you stole by Owen Jacobson

Owen Jacobson — Fri, 15 Jan 2010 01:23:06 +0000

Well, see, it’s not a big deal, because the interpreter starts, renders one page, and exits (destroying everything).

Hope you didn’t want to write a long-running program that isn’t a web page in it.

Comment on My purity you stole by Grumqa

Grumqa — Fri, 15 Jan 2010 01:22:13 +0000

So does it just purge the function table now and then? It must be doing something so as not to blow up the server because somebody hit a page that creates a function too many times.

Comment on My purity you stole by Owen Jacobson

Owen Jacobson — Fri, 15 Jan 2010 01:12:55 +0000

For some ideas on how to abuse this in Objective-C, consider the links under isa swizzling. (Objective-C calls the pointer to an object's virtual method table isa.)

Comment on My purity you stole by Owen Jacobson

Owen Jacobson — Fri, 15 Jan 2010 01:05:19 +0000

No; C++’s virtual function tables are entirely generated at compile time, and the names are real symbols (well, fixed offsets) rather than string literals. This is a little easier to see in Objective-C, where the symbol table is in easy reach, but you can model C++’s behaviour with this C:

#include 
 
/*
class a {
public:
    const char *get_message();
    a(const char *);
private:
    const char *message;
};
*/
 
struct a {
    const char *message;
};
 
struct a_virt {
    const char *(*get_message)(
        struct a *this,
        const struct a_virt *this_vtable
    );
    void (*__constructor__)(
        struct a *this,
        const struct a_virt *this_vtable,
        const char *message
    );
};
 
/* const char *a::get_message() */
const char *a__get_message(
    struct a *this,
    const struct a_virt *this_vtable
) {
    return this->message;
}
 
/* a::a(const char*) */
void a____constructor__(
    struct a *this,
    const struct a_virt *this_vtable,
    const char *message
) {
    /* No base class to delegate to. */
    this->message = message;
}
 
/* The actual virtual table for class a */
const struct a_virt a_virt = {a__get_message, a____constructor__};
 
/*
class b : public a {
public:
    b(const char *);
    void print();
private:
    const char *message;
};
*/
 
struct b {
    /* Fields inherited from type 'a' -- taking advantage
       of an oddity of the C structure padding rules, this
       is even legal as-is. Just ill-advised. */
    const char *message;
 
    /* No new fields in 'b'. */
};
 
struct b_virt {
    /* Methods inherited from a */
    const char *(*get_message)(
        struct a *this,
        const struct a_virt *this_vtable
    );
 
    /* Local methods. */
    void (*__constructor__)(
        struct b *this,
        const struct b_virt *this_vtable,
        const char *message
    );
    void (*print)(
        struct b *this,
        const struct b_virt *this_vtable
    );
};
 
void b____constructor__(
    struct b *this,
    const struct b_virt *this_vtable,
    const char *message
) {
    /* Chain to a::a */
    a____constructor__(this, this_vtable, message);
}
 
void b__print(struct b *this, const struct b_virt *this_vtable) {
    /* Call this->get_message() */
    const char *message = this_vtable->get_message(this, this_vtable);
    printf("%s\n", message);
}
 
/* The actual vtable for type b */
const struct b_virt b_virt = {
    a__get_message,
    b____constructor__,
    b__print
};
 
int main() {
    /* Create a b */
    struct b instance_of_b;
    b_virt.__constructor__(&instance_of_b, &b_virt, "Hello, world.");
 
    /* Call b.print() */
    b_virt.print(&instance_of_b, &b_virt);
}

$ ./virtual-demo
Hello, world.

All of this happens at compile time.

As for the second part of your question:


 
$x = create_function('', 'return 0;');
$y = create_function('', 'return 0;');
 
print $x == $y; /* Prints nothing (FALSE). */
 
?>

So yes, it does re-create the function every time it’s called, even if you give it the exact same code. This doesn’t really surprise me; caching function bodies is the sort of advanced feature that needs to be implemented differently in every program.

Comment on My purity you stole by Grumqa

Grumqa — Fri, 15 Jan 2010 00:36:15 +0000

Doesn’t C++ sort of do the same thing with virtual functions? What would you have it do instead?

I’d be curious to know if it creates a new function every time it is called with the same arguments.

Comment on I really don’t know what you mean by Owen Jacobson

Owen Jacobson — Tue, 12 Jan 2010 02:15:44 +0000

Ooh. Is there a bug for this somewhere? Searching the PHP bugs database for “array” or “index” is a lot time consuming.