TOC PREV NEXT INDEX

Put your logo here!


Overview

What is a "High Level Assembler"?

What is an "Assembler"

Is HLA a True Assembly Language?

HLA Design Goals

How to Learn Assembly Programming Using HLA

Legal Notice

Installing HLA Under Windows

Installing HLA Under Linux

Using HLA with the RadASM Integrated Development Environment

Using HLA with the HIDE Integrated Development Environment

HLA Internal Operation

Standard Configurations Under Windows
Standard Configurations Under Linux
Non-Standard Configurations Under Windows and Linux

Using the HLA Command-Line Compiler

The HLAPARSE Command Line

Customizing HLA

Changing the Location of HLA
Setting Auxiliary Paths
Setting the Default Back-End Assembler
Setting the Default Linker

HLA Language Elements

Comments
Special Symbols
Reserved Words
External Symbols and Assembler Reserved Words
HLA Identifiers
External Identifiers
Data Types in HLA
Native (Primitive) Data Types in HLA
Enumerated Data Types
HLA Type Compatibility
Composite Data Types
Array Data Types
Union Data Types
Record Data Types
Pointer Types
Thunks
Class Types
Regular Expression Types
Literal Constants
Numeric Constants
Decimal Constants
Hexadecimal Constants
Binary Constants
Numeric Set Constants
Real (Floating Point) Constants
Boolean Constants
Character Constants
Unicode Character Constants
String Constants
Unicode String Constants
Character Set Constants
Structured Constants
Array Constants
Record Constants
Union Constants
Pointer Constants
Regular Expression Constants
Constant Expressions in HLA
Type Checking and Type Promotion
Type Coercion in HLA
!expr
- expr (unary negation operator)
expr1 * expr2
expr1 div expr2
expr1 mod expr2
expr1 / expr2
expr1 << expr2
expr1 >> expr2
expr1 + expr2
expr1 - expr2
Comparisons (=, ==, <>, !=, <, <=, >, and >=)
expr1 & expr2
expr1 in expr2
expr1 | expr2
expr1 ^ expr2
( expr )
[ comma_separated_list_of_expressions ]
record_type_name : [ comma_separated_list_of_field_expressions ]
identifier
identifier1.identifier2 {...}
identifier [ index_list ]
Program Structure
Statement Labels
Procedure Declarations
Disabling HLA's Automatic Code Generation for Procedures
Procedure Calls and Parameters in HLA
Calling HLA Procedures
Parameter Passing in HLA, Value Parameters
Parameter Passing in HLA, Reference, Value/Result, and Result Parameters
Untyped Reference Parameters
Parameter Passing in HLA, Name and Lazy Evaluation Parameters
Hybrid Parameter Passing in HLA
Parameter Passing in HLA, Register Parameters
Lexical Scope
Declarations
Label Section
Type Section
Const Section
Val Section
Var Section
Static Section
Segments
Readonly Section
Storage Section
Variable Options
The @NOSTORAGE Option
The @VOLATILE Option
The @PASCAL, @CDECL, and @STDCALL Options
The @RETURNS Option
The @EXTERNAL Option
Segment Names
Namespaces
Class Data Types
Classes, Objects, and Object-Oriented Programming in HLA
Inheritence
Abstract Methods
Classes versus Objects
Initializing the Virtual Method Table Pointer
Creating the Virtual Method Table
Calling Methods and Class Procedures
Non-object Calls of Class Procedures
Static Class Fields
Taking the Address of Class Procedures, Iterators, and Methods
Program Unit Initializers and Finalizers
HLA High Level Language Statements
Exception Handling in HLA
The IF..THEN..ELSEIF..ELSE..ENDIF Statement in HLA
Boolean Expressions for High-Level Language Statements
The WHILE..WELSE..ENDWHILE Statement in HLA
The REPEAT..UNTIL Statement in HLA
The FOR..ENDFOR Statement in HLA
The FOREVER..ENDFOR Statement in HLA
The BREAK and BREAKIF Statements in HLA
The CONTINUE and CONTINUEIF Statements in HLA
The BEGIN..END, EXIT, and EXITIF Statements in HLA
The JT and JF Medium Level Instructions in HLA
Iterators and the HLA Foreach Loop
HLA Compile-Time Language and Pragmas
The #Include Directive
The #IncludeOnce Directive
Macros
Standard Macros
Where You Declare a Macro Affects its Visibility
Multi-part (Context Free) Macro Invocations:
Macro Invocations and Macro Parameters:
Processing Macro Parameters
Built-in Functions:
Constant Type Conversion Functions
Bitwise Type Transfer Functions
General functions
String functions:
String/Pattern matching functions
Symbol and constant related functions and assembler control functions
Pseudo-Variables
Text emission functions
Miscellaneous Functions
#Text and #endtext Text Collection Directives
#String and #endstring Text Collection Directives
Regular Expression Macros and the @match/@match2 Functions
#regex..#endregex
The #return Clause
Regular Expression Elements
Kleene Star, Plus, and Numeric Range Specifications 191
Matching Characters in a Regular Expression 192
Case-insensitive Character Matching in a Regular Expression 192
Negated Character Matching 193
String Matching in Regular Expressions 193
Case-insenstive String Matching in Regular Expressions 194
Negated String Matching 194
String List Matching 194
Character Set Matching in a Regular Expression 195
Negated Character Set Matching 195
Matching Arbitrary Characters 195
Sequences (Concatenation) - The `,' Operator 196
Alternation - The "|" Operator 196
Subexpressions - The "()" operator 197
Extracting Substrings - The Extraction Operator "<>:" 197
Invoking Other #regex Macros in a Regular Expression 198
Lookahead (peeking) 198
Utility Matching Functions 199
Backtracking
Lazy Versus Greedy Evaluation
The @match and @match2 Functions
Compiling and Precompiling Regular Expressions
The #match..#endmatch Block
Using Regular Expressions in Your Assembly Programs
The #asm..#endasm and #emit Directives
The #system Directive
The #print and #error Directives
Compile-Time File Output (#openwrite, #append, #write, #closewrite)
Compile-time File Input (#openread, @read, #closeread)
The Conditional Compilation Statements (#if)
The Compile-Time Loop Statements (#while and #for)
Compile-Time Functions (macros)
HLA Units and External Compilation
External Declarations
HLA Naming Conventions and Other Languages
HLA Calling Conventions and Other Languages
Calling Procedures Written in a Different Language
Calling HLA Procedures From Another Language
Linking in Code Written in Other Languages

The 80x86 Instruction Set in HLA

Zero Operand Instructions (Null Operand Instructions)
General Arithmetic and Logical Instructions
The XCHG Instruction
The CMP Instruction
The Multiply Instructions
The Divide Instructions
Single Operand Arithmetic and Logical Instructions
Shift and Rotate Instructions
The Double Precision Shift Instructions
The Lea Instruction
The Sign and Zero Extension Instructions
The Push and Pop Instructions
Procedure Calls
The Ret Instruction
The Jmp Instructions
The Conditional Jump Instructions
The Conditional Set Instructions
The Conditional Move Instructions
The Input and Output Instructions
The Interrupt Instruction
Bound Instruction
The Enter Instruction
CMPXCHG Instruction
CMPXCHG8B Instruction
The XADD Instruction
BSF and BSR Instructions
The BSWAP Instruction
Bit Test Instructions
Floating Point Instructions
Additional Floating Point Instructions for Pentium Pro and Later Processors
MMX Instructions
SSE Instructions
OS/Priviledged Mode Instructions
Other Instructions and features

Memory Addressing Modes in HLA

Type Coercion in HLA



TOC PREV NEXT INDEX