Talk:High-level assembler
 | This article is rated Start-class on Wikipedia's content assessment scale. It is of interest to the following WikiProjects: | ||||||||||||||||
| |||||||||||||||||
A VANDAL HAS DELETED ALL THE INFO Belgian man 19:43, 4 Oct 2004 (UTC)
- Seems okay now? Zuiram 09:08, 23 November 2006 (UTC)
Lack of notability
editIMHO this subject should be deleted, because the term "high level assembler" is not established. I think I'm an assembler expert. None of my 20 or so books contains the term "high level assembler", and on the internet I only find the vagaries of Randall Hide. Adding conditional compilation, macro's or facilities to more easily call external facilities (in higher level languages like C) are unsufficient ground. Especially not because it is hard to find a serious tool that doesn't allow for conditional compilation and/or macro's. Once there are macro's you can easily add facilities for external calls.
If the information here is to be salvaged, the subject should be renamed. Even so the information could better be distributed over subjects like "calling high level languages from assembler" . A good article would probably be dismissed as "original research". 80.100.243.19 (talk) 16:28, 7 May 2011 (UTC)
- You're right about the Hyde system not being a real high level assembler despite its name - it's clearly a programming language, modelled on C# or some other equivalent modern language. However the term most definitely was in common use in the 60's and 70's. I've added a reference link to Hamish Dewar's "HAL70" (the 70 refers to the Interdata minis, not the year) which was published in 1975. If you read the manual it is very clearly in the style as described in the article section. Dewar's HAL was relatively portable, and was also implemented for the ICL7502 editing station (by Dewar) as well as for the ICL 2900 series and the DEC KMC11 by others. 70.124.38.160 (talk) 05:39, 25 April 2024 (UTC)
PL/360
editWhile PL/360 had features that the IBM D, F and XF assemblers lacked, it's lack of an equivalent to USING and its lack of macros left it arguably lower level than the assemblers bundled with the IBM S/360 and S/370 operating systems. Shmuel (Seymour J.) Metz Username:Chatul (talk) 19:07, 11 September 2013 (UTC)
ESPOL seems to be more than just an assembler
editESPOL seems to be more than just an assembler, even a "high-level" assembler; it does more than just "[provide] an ALGOL-like syntax around explicitly-specified Burroughs B5000 machine instructions" - it allows, for example, arbitrary high-level-language-style expressions, not just explicitly specified operand call and arithmetic instructions.
It's more of a system programming language, in that, while you can, at least with the B5xxx ESPOL, use POLISH to write machine-language instructions directly, and can make various machine-specific references, that's not the only kind of code you can put inside higher-language control flow constructs. Guy Harris (talk) 08:04, 15 May 2024 (UTC)
So what does, and what doesn't, qualify as a "high-level assembler"?
editIn the Assemblers and Loaders book cited as a reference, section 6.1 "High-Level Assemblers" says that "there is no general agreement on how to define [high-level assemblers], on what their main features should be ...", and that "Existing high-level assemblers differ in many respects and, on looking at several of them, two possible definitions emerge".[1]
The first definition is for a language "where each instruction is translated into a few machine instructions" and that lacks higher-level flow control constructs such as if, for, and case, and where statements "closely [resemble] traditional assembler instructions".
The second definitions is for a language "that combines most of the features of higher-level languages" with machine-dependence.
That section then goes on to discuss a few languages that do not precisely fit either definition:
- NCR's NEAT/3 - it has a tabular language to define records, which requires explicit numeric values for the offsets of fields within the record, COBOL-style PICTUREs for fields, branch-based conditionals, and simple statements that usually turn into a small number of instructions (possibly only one instruction).
- PL360 - it has high-level flow-control constructs, and allows arithmetic expressions, but the evaluation rules for the expressions are simple enough (left-to-right, no precedence) that they fairly straightforwardly map to instructions, and the general-purpose and floating-point registers can be directly accessed by name.
- PL516, for the DDP-516 - it has high-level flow-control constructs, and allows arithmetic expressions, but the expressions can't use temporary storage, and the accumulator can be directly accessed by name.
- BABBAGE, for the GEC 4000 series - it has simple expressions (no precedence, no parentheses), simplified if-then-else, while, and repeat constructs, and... pointers and Pascal-like records.
The latter three all have one-dimensional arrays.
The first language that the article lists is ESPOL, which has a number of features in common with Burroughs Extended ALGOL (a superset of ALGOL 60), such as high-level flow-control constructs, arrays, arithmetic expressions with parentheses and precedence, both local (auto, for C/C++ fans) and own (static variables, function calls, etc. - the B5500 ESPOL manual points the reader to the Extended ALGOL manual for much of that. It has a bunch of machine-specific constructs, a POLISH (as in "Polish notation", as the machines for which ESPOL is used are stack machines), allowing embedded assembler code (there's no assembler for those machines, but if you need assembler code, that's how you do it).
I wouldn't call that a "high-level assembler"; it's a system programming language with constructs that allow direct access to the hardware if needed.
C is similar, except that it doesn't have features for direct access to any particular process's hardware. It does let you play tricks with pointers, although it makes no guarantees about what will happen - you have to know what works and what doesn't - and that's about it. GCC and Clang provide inline assembler (asm) constructs if you need to drop into assembler language. It's also not a "high-level assembler". (And if you want a simple relationship between the C code you write and the machine code that gets generated, I suggest that, for most compilers, you disable the optimizer.) Guy Harris (talk) 07:05, 13 August 2025 (UTC)
References
- ^ Salomon, David (February 1993) [1992]. Written at California State University, Northridge, California, USA. Chivers, Ian D. (ed.). Assemblers and Loaders (PDF). Ellis Horwood Series In Computers And Their Applications (1 ed.). Chicester, West Sussex, UK: Ellis Horwood Limited / Simon & Schuster International Group. ISBN 0-13-052564-2.