Table of content

•	Table of Contents
•	Examples

Programming for the Java™ Virtual Machine
By Joshua Engel
Publisher	: Addison Wesley
Pub Date	: June 22, 1999
ISBN	: 0-201-30972-6
Pages	: 512
	Copyright
		Preface
			Prerequisites
			Books
			Acknowledgments
		Chapter 1.  Introduction to the Java Virtual Machine
			Section 1.1.  Java Virtual Machine and Java
			Section 1.2.  What Is the Java Virtual Machine?
			Section 1.3.  Java Platform
			Section 1.4.  Organization of the Java Virtual Machine
			Section 1.5.  Garbage Collection
			Section 1.6.  JVM Implementations
			Section 1.7.  Versions of the Virtual Machine
			Section 1.8.  Future of the Java Virtual Machine
		Chapter 2.  Oolong
			Section 2.1.  Hello, World
			Section 2.2.  Structure of an Oolong Program
			Section 2.3.  Defining the Class
			Section 2.4.  Superclasses
			Section 2.5.  Declaring Fields
			Section 2.6.  Declaring Methods
			Section 2.7.  Interfaces
		Chapter 3.  Writing Methods
			Section 3.1.  Some Definitions
			Section 3.2.  Types
			Section 3.3.  Mnemonic Naming Conventions
			Section 3.4.  Testing Code Examples
			Section 3.5.  Returns
			Section 3.6.  Constants
			Section 3.7.  Local Variables
			Section 3.8.  Math
			Section 3.9.  Type Conversions
			Section 3.10.  Stack Manipulations
			Section 3.11.  Arrays of Numbers
			Section 3.12.  Just Biding Your Time
		Chapter 4.  Classes and Objects
			Section 4.1.  What Is an Object?
			Section 4.2.  Creating Objects
			Section 4.3.  Constructors
			Section 4.4.  Using Fields
			Section 4.5.  Invoking Methods on Objects
			Section 4.6.  Casting
			Section 4.7.  Casting, Fields, Methods, and Java
			Section 4.8.  Returning Objects
			Section 4.9.  Interfaces
			Section 4.10.  Static Fields and Methods
			Section 4.11.  Class Initialization
			Section 4.12.  Arrays
		Chapter 5.  Control Instructions
			Section 5.1.  Comparing Integers
			Section 5.2.  Comparing References
			Section 5.3.  Other Comparisons
			Section 5.4.  Switches
			Section 5.5.  Subroutines
			Section 5.6.  Exceptions
			Section 5.7.  A Gentler Way of Checking Type
		Chapter 6.  Verification Process
			Section 6.1.  How the Verification Algorithm Works
			Section 6.2.  Is It a Structurally Valid class File?
			Section 6.3.  Are All Constant References Correct?
			Section 6.4.  Are All the Instructions Valid?
			Section 6.5.  Will Each Instruction Always Find a Correctly Formed Stack and Local Variable Array?
			Section 6.6.  Do External References Check Out?
			Section 6.7.  Java Language and Verification Algorithm
			Section 6.8.  Other Safety Requirements
			Section 6.9.  Checking Verification
		Chapter 7.  Debugging
			Section 7.1.  Debugging Directives in Oolong
			Section 7.2.  Debugging Oolong Programs
			Section 7.3.  Runtime Tracing
		Chapter 8.  Class Loaders
			Section 8.1.  How Classes Are Loaded
			Section 8.2.  Loading Classes without a Class Loader
			Section 8.3.  Making Your Own Class Loader
			Section 8.4.  Working with Class Objects
			Section 8.5.  Reflection
		Chapter 9.  Inside a Java class File
			Section 9.1.  class File Header
			Section 9.2.  Constant Pool
			Section 9.3.  Class Information
			Section 9.4.  Fields and Methods
			Section 9.5.  Class Attributes
			Section 9.6.  Other Attributes
		Chapter 10.  Compiling Java
			Section 10.1.  Expressions and Statements
			Section 10.2.  Expression Types
			Section 10.3.  Compiling Statements and Expressions
			Section 10.4.  Local Variable Declarations
			Section 10.5.  Fields and Variables
			Section 10.6.  Creating New Objects
			Section 10.7.  Class Name Abbreviations
			Section 10.8.  Arithmetic Expressions
			Section 10.9.  Method Calls
			Section 10.10.  Expressions as Statements
			Section 10.11.  Ifs and Booleans
			Section 10.12.  Other Control Structures
			Section 10.13.  Returns
			Section 10.14.  Field Declarations
			Section 10.15.  Method Declarations
			Section 10.16.  Constructors
			Section 10.17.  Conclusion
		Chapter 11.  Compiling Other Languages
			Section 11.1.  Java Version 1.1
			Section 11.2.  Regular Expressions
			Section 11.3.  Iterators
			Section 11.4.  Parameterized Types
			Section 11.5.  Multiple Inheritance
			Section 11.6.  Conclusion
		Chapter 12.  Implementing Scheme
			Section 12.1.  Scheme Concepts
			Section 12.2.  Compiling Scheme into Bytecodes
			Section 12.3.  Compiling Lambda Expressions
			Section 12.4.  Example
			Section 12.5.  Scheme Library
			Section 12.6.  Optimizing Scheme
		Chapter 13.  Implementing Prolog
			Section 13.1.  Introduction to Prolog
			Section 13.2.  Implementation Basics
			Section 13.3.  Unification
			Section 13.4.  Rules as Programs
			Section 13.5.  Implementing Rules
			Section 13.6.  Compiling Facts
			Section 13.7.  Case Study
		Chapter 14.  Performance
			Section 14.1.  Fast Virtual Machines
			Section 14.2.  Bytecode Optimization Techniques
			Section 14.3.  Inlining
		Chapter 15.  Security and the Virtual Machine
			Section 15.1.  Java Platform and Need for Security
			Section 15.2.  Security Promises of the JVM
			Section 15.3.  Security Architecture and Security Policy
			Section 15.4.  Some Potential Attacks
			Section 15.5.  Conclusion
		Chapter 16.  Threads and Synchronization
			Section 16.1.  Threads
			Section 16.2.  Sharing State Between Threads
			Section 16.3.  Monitors and Object Locks
			Section 16.4.  Scheduling
			Section 16.5.  Conclusion
		Appendix A.  Tables
			Section A.1.  Instructions by Opcode
			Section A.2.  Instructions Alphabetically
			Section A.3.  Instructions by Category
		Appendix B.  Oolong Reference
			Section B.1.  Using the Oolong Assembler
			Section B.2.  Gnoloo
			Section B.3.  DumpClass
			Section B.4.  Oolong Language
			Section B.5.  Instructions
		Appendix C.  Answers to Selected Exercises
		Further Reading
			Java and the JVM
			Newsgroup
			Other Languages
			Compilers