Fixed memory protection conditions (now that I finally have a GC test case) and implemented a ctrl-c execution cancel mechanism.

Fixed serialization of function w/ CYNoLeader and implemented line tokenization for multi-line readline() events.

Slightly reorganized code, fixed @class to work with NoBF principal, integrated the prototype chain (with special exceptions for NSDictionary and NSArray), added some safety to the Instance_*_callAsFunction methods, and renamed Class.prototype to Class.messages.

Not quite the original, but pretty damn near close.

Added a website folder.

Started work on array comprehensions, implemented multi-line string literals (not for console yet), and refactored @class to be an expression (with support for anonymous classes).

CYJSObject objectForKey: should be returning nil for undefined keys.

CYJSArray is actually supposed to be throwing NSRangeException.

Fixed [Array objectAtIndex: > .length] to return nil.

Support complete back/forth mapping between NSMutableArray and Array.

Made Selector derive from Function, fixed numerability of Instance.{constructor,prototype,value}, renamed data to internal across-the-board, swapped orderring of ivar iteration to put superclasses first, made Prototype's prototype be the superclasses Prototype, implemented labelled statement serialization, and hammered away at a stupid corner case involving blocks and statment serialization.

Started setting up build environment for Cyrver, fixed Functor prototype, organized ffoData, and added a mechanism to access the .prototype of a Class.

Fail to auto-@property get a void return.

Improved lexical syntax errors and added not-isatty detection for selecting the parser algorithm.

Fixed one stupid CYON bug in what was otherwise an awesome release.

Broke apart Connector from Library and fixed cases where '- -' was serialized as '--'.

Fleshed out support for &, reworked nil internally, setup new Instance(), and implemented hasProperty across-the-board.

Renamed Application.cpp to Console.cpp.

Changed console commands to start with ? and added ?expand to unescape strings.

I think this objectiriddification will finally stick.

Got the makefile to not rebuild the .deb constantly, and decided to attempt property autodetection.

Implemented ->, &, and fleshed out *.

Implemented ivar access, added some general runtime reflection hierarchy, changed NSCFType.toJSON to use CFCopyDescription, fixed a few bugs in the server/client interaction involving exceptions not getting propogated, further fleshed out CoreFoundation bridging, setup CYSend:: for CYNoLeader flags, and messed with the overall mechanism for converting objects into descriptions (including memory management, naming, and safety for weird types).

Support -p and <script> at the same time.

Improved console syntax error reporting.

Attempted to refactor grammar slightly to obtain better code reuse.

Added some common methods to Type class, implemented new Type(size), removed some debugging code from the server, simplified Selector.type to one class argument, and refactored property names for the new class name serialization.

Added Instance constructor instance (for Instance.prototype), implemented Type class, refactored memory management of Type_privateData, fixed a couple missing spaces in serialization (such as 'newnew'), and dealt with the extra bad exceptions that weren't being caught (unrecognized selectors).

Finally got process attach stable.

Fixed number output formatting (to avoid accidental rounding) and removed length parameter from CYPoolCString.

Fixed a stupid set of bugs that broke HelloCycript: first a NULL dereference in sig::Parse, and second trying to cast objc_registerClassPair to a Class rather than its argument.

Solve a corner case of dealloc hooking on JS derived class objects using MobileSubstrate.

Added a lot of bridge supports, setup for enum and typedef, implemented cy object property storage, and slightly improved CYData factorization.

Protect bash glob expansions while generating libcycript.plist (thanks to kennytm), reorganized makefile gcc arguments slightly, removed CYApplicatonMain hack, support new Pointer to associate types to addresses, setup sig::Parse callbacks to later support circular type definitions, began reworking objc_registerClassPair to support tacking on extra Cycript features, and implemented a horrid temporary hack to allow @class objects to have a single JavaScript Instance object (at the extreme cost of simply leaking the entire Objective-C object).

Fix line numbers of errors caused in executed scripts due to lopping off the first line, removed CYApplicationMain temporary hack, implemented new Pointer for binding a type to an address, and slightly rearranged gcc makefile arguments.

Fixed an issue where I could no longer create pointers to void.

Implemented pointer indirect assignment.

Implemented pointer indirection.

Finished the memory manager.

Added bridging for nlist_64, activated memory manager, and setup a remap from singleton unions to structs.

Started working on CYApplicationMain replacement, added bridging for some Foundation core types, and fixed issues caused by working with structs that are missing name bridges.

Implemented structure field names, removed parentheses from NSDictionary CYON, and made quotations around propery name CYON optional.

Implemented @property access, made Pointer.toCYON printf %p, added UIWindow bridge support, cache selectors for objc_msgSend, and slightly refactored the message sending and function calling APIs.

Moved HTTP server to its own file, implemented toJSON support, split off CYON from JSON, changed cy to a more general cy, added copyright notices, and optimized string serialization (using correct quoting as appropriate for single/double quote density).

Minor refactoring, checkpoint commit.

Fixed [4 longLongValue] == 1.522122665807053e+16.

Added more UIKit bridging, better factored property access on structs (fixing a crash bug if you fell off the end), and test svnversion for .deb construction.

Remove system.global temporarily, added libffi Depends:, and setup REPL with _ variable for result.

Add CFShow* to Bridge.

Remove e: debugging NSLog.

Output all message declarations (not just one or the first and last), flesh out some UIKit bridging, fix Instance toString() memory allocation, and copy all structure fields (not just the last one onto the first element).

Mostly implemented Struct support.

Tried to unify naming of classes, removed usages of JSC-specific parentClass, added a separate obc. namespace, moved Global's functionality out to a Runtime prototype, refactored Bridge to keep separate selector/C namespaces, registered dlfcn names, typed up a quick todo list, and started using .valueOf() to get pointer values.

I hate NSNull.

Added support for array and dictionary property access.

Drastic modifications to exception handling that required temporarily bringing back Objective- for the core Application :(.

Further memory management improvements, fixed some weird vtable bugs with CYThis, ripped Objective- from the C++ of the core application (Dalvik preparation), corrected the bitification of the CYFlags enum, and implemented Objective-C to JavaScript transition.

Drastic improvements to memory management, handle many more minimization corner cases via CYFlags (like NoIn), added support for @class, implemented Selector.type, and support execution of script files.

Added some documentation links for reference.

Added console commands.

Further normalization and fixed some output cases.

Docuemented some precedence rules (going to target a more normalized parser).

Fixed a stupid bug that caused ?: to crash.

Drastically improved serializer.

Fixed argument serialization comma bug.

Serialise JSON WebUndefined's in NSArray as JS elision.

Implemented CYSelector::Output, split CYSelectorPart, and further enforced CYNext.

Change mind (again) and use tightly-coupled C++ API.

Support tokenization errors.

Finished implementing strings.

Readline integration and console refactoring.

Locations, array literal elisions, and fixed prompting.

More interactivity and @selector start.

Picked some minor nits.

Factored away all LALR(1) conflicts and gave up on GLR.

Implemented automatic semicolon insertion token restrictions.

Unified scanner state.

Escaped the Q Continuum.

Finished implementing automatic semi-colon rules, but failed hard at fixing multi-line comments.

I nailed the interactive parser!

Connected the console back together.

Added output generation.

I finally finished the AST.

Maybe finished lexer.

The glue code required for Bison/Flex parsers is insane.

C++ Bison conversion.

Finished JS Bison/Flex parser.

OMG it compiles.

Checkpoint before something drastic.

Ready to start testing the parser.

Use _pooled in CYConsole.

Refactored console mechanism.

Temporarily remove MobileSubstrate extension.

Fixed clean target.

Renamed the project to cycript.

Minor code cleaning.

Stupid _assert() throw-away.

Improved error handling.

Support bridge support variables.

Initial bridge support.