| Age | Commit message (Collapse) | Author |
|---|
|
This makes variable and property lookups a lot faster since comparing
two FlyStrings is O(1).
|
|
This patch implements basic parsing of "if" statements. We don't yet
support parsing "else", so I added a FIXME about that.
|
|
|
|
These should always pass the arguments in a const Vector<JS::Value>&.
|
|
Object now has virtual get_own_property() and put_own_property() member
functions that can be overridden to provide custom behavior.
We use these virtuals to move Array-specific access behavior to Array.
|
|
HeapBlocks now show up in SystemMonitor as "LibJS: HeapBlock(32)" :^)
|
|
- move() the property map when constructing ObjectExpression instead of
making a copy.
- Use key+value iterators to traverse the property map in the execute()
and dump() functions.
|
|
This increases HeapBlock utilization significantly (and reduces overall
memory usage.)
|
|
We now deallocate GC blocks when they are found to have no live cells
inside them.
|
|
|
|
This function is ultimately supposed to be generic and allow any |this|
that has a length property, but for now it only works on our own Array
object type.
|
|
I'm not completely thrilled about Object::get() and Object::put() doing
special-case stuff for arrays, and we should probably come up with a
better abstraction for it.
But at least it works for now, which is really nice. :^)
|
|
MemberExpression comes in two flavors:
computed: a[b]
non-computed: a.b
We can now parse both of the types. :^)
|
|
|
|
Note that property lookup is not functional yet.
|
|
|
|
|
|
|
|
This is pretty naive, we just walk up the prototype chain and call any
NativeProperty setter that we find. If we don't find one, we put/set
the value as an own property of the object itself.
|
|
FunctionExpression is mostly like FunctionDeclaration, except the name
is optional. Share the parsing logic in parse_function_node<NodeType>.
This allows us to do nice things like:
document.addEventListener("DOMContentLoaded", function() {
alert("Hello friends!");
});
|
|
Most of the code is shared with FunctionDeclaration, so the shared bits
are moved up into a common base called FunctionNode.
|
|
Using make<T> like this would create an unadopted object whose refcount
would never reach zero.
|
|
|
|
This is pretty heavy and unoptimized, but it will do the trick for now.
Basically, Heap now has a HashTable<HandleImpl*> and you can call
JS::make_handle(T*) to construct a Handle<T> that guarantees that the
pointee will always survive GC until the Handle<T> is destroyed.
|
|
I'm not exactly sure why we end up in this situation, we'll have to
look into it.
|
|
|
|
This helper function takes care of pushing/popping a call frame so you
don't need to worry about it.
|
|
This allows function objects to outlive the original parsed program
without their ScopeNode disappearing.
|
|
|
|
Now that Interpreter keeps all arguments in the CallFrame stack, we can
just pass a const-reference to the CallFrame's argument vector to each
function handler (instead of copying it.)
|
|
This patch adds a CallFrame stack to Interpreter, which keeps track of
the "this" value and all argument values passed in function calls.
Interpreter::gather_roots() scans the call stack, making sure that all
argument values get marked. :^)
|
|
This is very useful for discovering collector bugs.
|
|
We now scan the stack and CPU registers for potential pointers into the
GC heap, and include any valid Cell pointers in the set of roots.
This works pretty well but we'll also need to solve marking of things
passed to native functions, since those are currently in Vector<Value>
and the Vector storage is on the heap (not scanned.)
|
|
|
|
Let's try to keep LibJS tidy as it expands. :^)
|
|
|
|
This commits makes effort towards tolerating some of javascript's quirks
when it comes to its type system, note that the interpreter's way of
handling type coercion is still not mature at all, for example, we still
have to implement NaN instead of just crashing when trying to parse a
string and failing.
|
|
|
|
|
|
|
|
We were previously assuming that we were reassigning a variable even
when we were not, oops, my bad. :/
|
|
|
|
Instead of every NativeFunction callback having to ask the Interpreter
for the current "this" value and then converting it to an Object etc,
just pass "this" as an Object* directly.
|
|
This patch adds NativeProperty, which can be used to implement object
properties that have C++ getters and/or setters.
Use this to move String.prototype.length to its correct place. :^)
|
|
|
|
All Objects will now have ObjectPrototype as their prototype, unless
overridden.
|
|
Since this is about finding the things we should *not* garabge collect,
it seemed wrong to call it "collect_something" :^)
|
|
To make sure that everyone has the same instance of StringPrototype,
hang a global prototype off of the Interpreter that can be fetched
when constructing new StringObjects.
|
|
This allows you to go from any Cell* to the Interpreter.
|
|
|
