Microsoft Technology Licensing, LLC

Sun Microsystems, Inc.

Google Inc.

Neal M Gafter

Mads Torgersen

Matthew J Warren

Henricus Johannes Maria Meijer

Niklas Gustafsson

David N Schach

Jared Porter Parsons

Peter H Golde

Aleksey V Tsingauz

Karen Liu

Renaud Paquay

Anders Hejlsberg

Avner Y Aharoni

Brian T Lewis

Bernd J W Mathiske

Samuel Ng

James J Hugunin

Lawrence Alan Crowl

Lucian Wischik

Robert Eric Lippert

Michael J Jordan

Kevin Pilch-Bisson

Christopher Joseph Burrows

Joshua J Bloch

Alex Christopher Turner

Kevin Andrew Pilch

Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared.

Efficient immutable syntax representation with incremental change

A static type, called 'dynamic', is introduced into a statically bound programming language. An expression or subexpression that is defined as a static type called 'dynamic' in the source code of a program written in the statically bound programming language, is bound based on its runtime type instead of on its compile time type. Binding can be performed based on a mixture of compile time and runtime types that are based on the specification of types of expressions in source code. This type of binding is called hybrid binding. Operations are bound using the runtime type of constituent expressions (i.e., the runtime type of a receiver, an argument, or an operand) typed as dynamic and the compile time type of static constituents. If any constituent expression of an operation is dynamic, binding occurs at runtime instead of at compile time.

Dynamic binding directed by static types

Unsuspended co-routines are handled by the machine call stack mechanism in which the stack grows and shrinks as recursive calls are made and returned from. When a co-routine is suspended, however, additional call stack processing is performed. A suspension message is issued, and the entire resume-able part of the call stack is removed, and is copied to the heap. A frame that returns control to a driver method (a resumer) is copied to the call stack so that resumption of the co-routine does not recursively reactivate the whole call stack. Instead the resumer reactivates only the topmost or most current frame called the leaf frame. When a co-routine is suspended, it does not return to its caller, but instead returns to the resumer that has reactivated it.

Efficient resumption of co-routines on a linear stack

APIs are provided, that are external to a programming language but that provide functionality that can be plugged into a language compiler. The provided APIs tailor functionality associated with asynchronous programming, iterators or writing symmetric co-routines using a generalized pattern-based approach. Several types of resumable methods are provided in the APIs which can be applied to method bodies written in traditional program code. Syntactically distinguishable control points in method bodies written in traditional program code invoke transformation of the code by the compiler using the external APIs. The transformed code enables the pausing and resumption of the code sandwiched between control points in the transformed code. The source code contained within a method having control points in it is transformed so that code within the method can be executed in discrete parts, each part starting and ending at a control point in the transformed code.

Resumable methods

Embodiments of this invention control access to documents by identifying a user requesting a document, retrieving a membership list associated with the user, retrieving an access control list (ACL) associated with the document, and intersecting the user's membership list and the document's ACL to determine if the user has privileges to access to the document. Certain embodiments of this invention filter documents in a search result to return those documents (or a list of those documents) that are accessible to a user.

Document access control

One embodiment of the present invention provides a system that facilitates use of an object-oriented enumerated type within a computer program. During operation, the system receives source code for the computer program, wherein the source code contains a declaration for an enumerated type. This declaration specifies a fixed number of enumeration constants that comprise the enumerated type. Next, the system defines the enumerated type using a class defined within an object-oriented programming language, wherein the class includes a constant for each enumeration constant specified in the declaration. If the declaration additionally contains one or more method declarations, these methods are present on the defined class.

Object-oriented enumerated type facility

Improved techniques for reducing the size of compiler products are disclosed. The techniques facilitate reduction of size by providing differential schemes aimed at producing compiler related information in a compressed form. The compressed compiler related information include symbol names associated with symbols encountered in programming languages. The improved techniques yield improved compilation times and compiler products that utilize substantially less storage space (e.g., disk storage space).

Method and apparatus for producing compressed compiler products

The present invention uses feedback to determine the size of an object cache. The size of the cache, (i.e., its budget), varies and is determined based on feedback from the persistent object system. Persistent objects are evicted from the cache if the storage for persistent objects exceeds the budget. If the storage is less than the budget then persistent objects in the heap are retained while new persistent objects are added to the cache.

Using feedback to determine the size of an object cache

Growing community of inventors

San Jose, CA, United States of America

Neal M Gafter