| Patent application number | Description | Published |
|---|
| 20110029960 | ENCAPSULATING AND MANAGING DIAGNOSTIC INFORMATION - The disclosed embodiments provide a system that encapsulates and manages diagnostic information. During operation, the system detects an event that generates diagnostic information, and stores this diagnostic information in a format that preserves semantic information associated with the event. The system also determines an output context (e.g., the intended target environment) for the diagnostic information, and then uses the preserved semantic information to output the diagnostic information in a context-sensitive format suited for the output context. Note that outputting customized diagnostic information that is adapted to a specific target environment facilitates improving the quality of diagnostic information presented to a user. | 02-03-2011 |
| 20110099535 | Encoding Switch on Ordered Universes with Binary Decision Diagrams - Various embodiments herein include one or more of systems, methods, software, and/or data structures to implement a multi-way branch statement in a computer programming language. The multi-way branch statement may include a plurality of case labels each having a non-primitive data type (e.g., strings) and being associated with a block of code to be executed dependent upon a control variable that also has a non-primitive data type. The implementation may include encoding the case labels for the multi-way branch statement as a binary decision diagram (BDD), such as a zero-suppressed binary decision diagram (ZDD), wherein the control variable for the multi-way branch statement may be compared with the case labels by stepping through the BDD. The BDD may include identifiers that provide information regarding which of the case labels is matched by the control variable, such that an appropriate code block may be executed. | 04-28-2011 |
| 20110179402 | METHOD AND SYSTEM FOR COMPILING A DYNAMICALLY-TYPED METHOD INVOCATION IN A STATICALLY-TYPED PROGRAMMING LANGUAGE - A method for compiling source code, involving: obtaining a statement of the source code comprising a method call, where the source code is composed in a statically-typed programming language; determining whether the method call is a dynamic method call; upon determining that the method call is a dynamic method call, compiling a dynamic method invocation without performing type checking on the method call; upon determining that the method call is not a dynamic method call: performing type checking on the method call, selecting a target method to invoke, and compiling a static method invocation to invoke the target method. | 07-21-2011 |
| 20110185344 | CHARACTERIZING ARTIFICIALITY IN OBJECT CODE - One embodiment of the present invention provides a system that characterizes content in object code. During operation, the system receives the source code of a program. The system also receives one or more pieces of object code of the program, or creates one or more pieces of object code from the source code. Next, the system identifies a construct in the object code. The system then determines whether the construct is physically present in the source code. If the construct is not physically present, the system determines whether the construct is logically present in the source code, wherein a construct is logically present if it is required by the programming language. If so, the system sets a construct flag to indicate that the construct is “synthesized.” However, if not, the system sets the construct flag to indicate that the construct is “synthetic.” Finally, the construct flag is made available to a reflective API. | 07-28-2011 |
| 20110271251 | ACCESS CONTROL IN MODULES FOR SOFTWARE DEVELOPMENT - The disclosed embodiments provide a system that provides access control for a software program. During operation, the system identifies a member of a module to be used in the software program. Next, the system infers the visibility of the member based on the accessibility of the member. Finally, the system uses the visibility and the accessibility to provide access control during the life cycle of the software program. | 11-03-2011 |
| 20110271254 | POLYPHASIC MODULES FOR SOFTWARE DEVELOPMENT - The disclosed embodiments provide a system that facilitates the development and maintenance of a software program. This system includes a software development kit (SDK) and a runtime system for the software program. During operation, the system associates classes of the software program with module declarations for a set of modules and uses the module declarations to manage dependencies in the software program throughout the life cycle of the software program. | 11-03-2011 |
| 20110321019 | COMPILE-TIME MANAGEMENT OF POLYPHASIC MODULES - The disclosed embodiments provide a system that facilitates the compilation of a software program. During operation, the system uses a directory hierarchy for the software program to infer a compilation unit to be used in the software program as a member of a module. Next, the system obtains a module declaration for the module using the directory hierarchy. Finally, the system enables compilation of the software program by dynamically identifying and locating one or more dependencies of the module using the module declaration and the directory hierarchy. | 12-29-2011 |
| 20120005660 | Type Inference of Partially-Specified Parameterized Types - A compiler receives source code for a program and determines that the code includes a declaration expression and an initialization expression in an assignment context. The declaration expression introduces a variable and specifies part of a parameterized type for the variable but not another part of the parameterized type. A parameterized type may include a ground type part and one or more type arguments; in a declaration expression, the specified part of the parameterized type may include a ground type and the unspecified part may include one or more of the type arguments. The initialization expression specifies an initial value for the variable, where the value has a parameterized type. The assignment context associates the declared variable with the initial value. The compiler infers the type for the variable based at least on the part specified in the declaration expression and on the type specified by the initialization expression. | 01-05-2012 |
