Books & Videos

Table of Contents

  1. Chapter 1 HELLO, WORLD OF ASSEMBLY LANGUAGE

    1. 1.1 The Anatomy of an HLA Program

    2. 1.2 Running Your First HLA Program

    3. 1.3 Some Basic HLA Data Declarations

    4. 1.4 Boolean Values

    5. 1.5 Character Values

    6. 1.6 An Introduction to the Intel 80x86 CPU Family

    7. 1.7 The Memory Subsystem

    8. 1.8 Some Basic Machine Instructions

    9. 1.9 Some Basic HLA Control Structures

    10. 1.10 Introduction to the HLA Standard Library

    11. 1.11 Additional Details About try..endtry

    12. 1.12 High-Level Assembly Language vs. Low-Level Assembly Language

    13. 1.13 For More Information

  2. Chapter 2 DATA REPRESENTATION

    1. 2.1 Numbering Systems

    2. 2.2 The Hexadecimal Numbering System

    3. 2.3 Data Organization

    4. 2.4 Arithmetic Operations on Binary and Hexadecimal Numbers

    5. 2.5 A Note About Numbers vs. Representation

    6. 2.6 Logical Operations on Bits

    7. 2.7 Logical Operations on Binary Numbers and Bit Strings

    8. 2.8 Signed and Unsigned Numbers

    9. 2.9 Sign Extension, Zero Extension, Contraction, and Saturation

    10. 2.10 Shifts and Rotates

    11. 2.11 Bit Fields and Packed Data

    12. 2.12 An Introduction to Floating-Point Arithmetic

    13. 2.13 Binary-Coded Decimal Representation

    14. 2.14 Characters

    15. 2.15 The Unicode Character Set

    16. 2.16 For More Information

  3. Chapter 3 MEMORY ACCESS AND ORGANIZATION

    1. 3.1 The 80x86 Addressing Modes

    2. 3.2 Runtime Memory Organization

    3. 3.3 How HLA Allocates Memory for Variables

    4. 3.4 HLA Support for Data Alignment

    5. 3.5 Address Expressions

    6. 3.6 Type Coercion

    7. 3.7 Register Type Coercion

    8. 3.8 The stack Segment and the push and pop Instructions

    9. 3.9 The Stack Is a LIFO Data Structure

    10. 3.10 Accessing Data You've Pushed onto the Stack Without Popping It

    11. 3.11 Dynamic Memory Allocation and the Heap Segment

    12. 3.12 The inc and dec Instructions

    13. 3.13 Obtaining the Address of a Memory Object

    14. 3.14 For More Information

  4. Chapter 4 CONSTANTS, VARIABLES, AND DATA TYPES

    1. 4.1 Some Additional Instructions: intmul, bound, into

    2. 4.2 HLA Constant and Value Declarations

    3. 4.3 The HLA Type Section

    4. 4.4 enum and HLA Enumerated Data Types

    5. 4.5 Pointer Data Types

    6. 4.6 Composite Data Types

    7. 4.7 Character Strings

    8. 4.8 HLA Strings

    9. 4.9 Accessing the Characters Within a String

    10. 4.10 The HLA String Module and Other String-Related Routines

    11. 4.11 In-Memory Conversions

    12. 4.12 Character Sets

    13. 4.13 Character Set Implementation in HLA

    14. 4.14 HLA Character Set Constants and Character Set Expressions

    15. 4.15 Character Set Support in the HLA Standard Library

    16. 4.16 Using Character Sets in Your HLA Programs

    17. 4.17 Arrays

    18. 4.18 Declaring Arrays in Your HLA Programs

    19. 4.19 HLA Array Constants

    20. 4.20 Accessing Elements of a Single-Dimensional Array

    21. 4.21 Sorting an Array of Values

    22. 4.22 Multidimensional Arrays

    23. 4.23 Allocating Storage for Multidimensional Arrays

    24. 4.24 Accessing Multidimensional Array Elements in Assembly Language

    25. 4.25 Records

    26. 4.26 Record Constants

    27. 4.27 Arrays of Records

    28. 4.28 Arrays/Records as Record Fields

    29. 4.29 Aligning Fields Within a Record

    30. 4.30 Pointers to Records

    31. 4.31 Unions

    32. 4.32 Anonymous Unions

    33. 4.33 Variant Types

    34. 4.34 Namespaces

    35. 4.35 Dynamic Arrays in Assembly Language

    36. 4.36 For More Information

  5. Chapter 5 PROCEDURES AND UNITS

    1. 5.1 Procedures

    2. 5.2 Saving the State of the Machine

    3. 5.3 Prematurely Returning from a Procedure

    4. 5.4 Local Variables

    5. 5.5 Other Local and Global Symbol Types

    6. 5.6 Parameters

    7. 5.7 Functions and Function Results

    8. 5.8 Recursion

    9. 5.9 Forward Procedures

    10. 5.10 HLA v2.0 Procedure Declarations

    11. 5.11 Low-Level Procedures and the call Instruction

    12. 5.12 Procedures and the Stack

    13. 5.13 Activation Records

    14. 5.14 The Standard Entry Sequence

    15. 5.15 The Standard Exit Sequence

    16. 5.16 Low-Level Implementation of Automatic (Local) Variables

    17. 5.17 Low-Level Parameter Implementation

    18. 5.18 Procedure Pointers

    19. 5.19 Procedural Parameters

    20. 5.20 Untyped Reference Parameters

    21. 5.21 Managing Large Programs

    22. 5.22 The #include Directive

    23. 5.23 Ignoring Duplicate #include Operations

    24. 5.24 Units and the external Directive

    25. 5.25 Namespace Pollution

    26. 5.26 For More Information

  6. Chapter 6 ARITHMETIC

    1. 6.1 80x86 Integer Arithmetic Instructions

    2. 6.2 Arithmetic Expressions

    3. 6.3 Logical (Boolean) Expressions

    4. 6.4 Machine and Arithmetic Idioms

    5. 6.5 Floating-Point Arithmetic

    6. 6.6 Converting Floating-Point Expressions to Assembly Language

    7. 6.7 HLA Standard Library Support for Floating-Point Arithmetic

    8. 6.8 For More Information

  7. Chapter 7 LOW-LEVEL CONTROL STRUCTURES

    1. 7.1 Low-Level Control Structures

    2. 7.2 Statement Labels

    3. 7.3 Unconditional Transfer of Control (jmp)

    4. 7.4 The Conditional Jump Instructions

    5. 7.5 "Medium-Level" Control Structures: jt and jf

    6. 7.6 Implementing Common Control Structures in Assembly Language

    7. 7.7 Introduction to Decisions

    8. 7.8 State Machines and Indirect Jumps

    9. 7.9 Spaghetti Code

    10. 7.10 Loops

    11. 7.11 Performance Improvements

    12. 7.12 Hybrid Control Structures in HLA

    13. 7.13 For More Information

  8. Chapter 8 ADVANCED ARITHMETIC

    1. 8.1 Multiprecision Operations

    2. 8.2 Operating on Different-Size Operands

    3. 8.3 Decimal Arithmetic

    4. 8.4 Tables

    5. 8.5 For More Information

  9. Chapter 9 MACROS AND THE HLA COMPILE-TIME LANGUAGE

    1. 9.1 Introduction to the Compile-Time Language (CTL)

    2. 9.2 The #print and #error Statements

    3. 9.3 Compile-Time Constants and Variables

    4. 9.4 Compile-Time Expressions and Operators

    5. 9.5 Compile-Time Functions

    6. 9.6 Conditional Compilation (Compile-Time Decisions)

    7. 9.7 Repetitive Compilation (Compile-Time Loops)

    8. 9.8 Macros (Compile-Time Procedures)

    9. 9.9 Writing Compile-Time "Programs"

    10. 9.10 Using Macros in Different Source Files

    11. 9.11 For More Information

  10. Chapter 10 BIT MANIPULATION

    1. 10.1 What Is Bit Data, Anyway?

    2. 10.2 Instructions That Manipulate Bits

    3. 10.3 The Carry Flag as a Bit Accumulator

    4. 10.4 Packing and Unpacking Bit Strings

    5. 10.5 Coalescing Bit Sets and Distributing Bit Strings

    6. 10.6 Packed Arrays of Bit Strings

    7. 10.7 Searching for a Bit

    8. 10.8 Counting Bits

    9. 10.9 Reversing a Bit String

    10. 10.10 Merging Bit Strings

    11. 10.11 Extracting Bit Strings

    12. 10.12 Searching for a Bit Pattern

    13. 10.13 The HLA Standard Library Bits Module

    14. 10.14 For More Information

  11. Chapter 11 THE STRING INSTRUCTIONS

    1. 11.1 The 80x86 String Instructions

    2. 11.2 Performance of the 80x86 String Instructions

    3. 11.3 For More Information

  12. Chapter 12 CLASSES AND OBJECTS

    1. 12.1 General Principles

    2. 12.2 Classes in HLA

    3. 12.3 Objects

    4. 12.4 Inheritance

    5. 12.5 Overriding

    6. 12.6 Virtual Methods vs. Static Procedures

    7. 12.7 Writing Class Methods and Procedures

    8. 12.8 Object Implementation

    9. 12.9 Constructors and Object Initialization

    10. 12.10 Destructors

    11. 12.11 HLA's _initialize_ and _finalize_ Strings

    12. 12.12 Abstract Methods

    13. 12.13 Runtime Type Information

    14. 12.14 Calling Base Class Methods

    15. 12.15 For More Information

  1. Appendix ASCII CHARACTER SET

  2. COLOPHON

  3. UPDATES