Chapter 9: Programming the CSC-1
Index of Terms
NOTE: Once you locate the term you want, you can immediately jump to that section of the book by clicking on the number on the right. That merely takes you to the beginning of the section, not necessarily to the place where the term occurs. You can use the browser's find or locate button or menu option to jump to the term.
activation record....................................... 9.5
address calculation..................................... 9.6
array................................................... 9.6
assembler............................................... 9.1
assembly language....................................... 9.1
base address............................................ 9.6
branches................................................ 9.4
call.................................................... 9.5
call by value/result.................................... 9.8
Captain Grace Hopper.................................... 9.1
compiler................................................ 9.1
control structures...................................... 9.4
dereferencing........................................... 9.7
flow of control......................................... 9.4
FORTRAN................................................. 9.1
frame................................................... 9.5
frame pointer........................................... 9.5
gcd program............................................. 9.4
goto.................................................... 9.4
IBM 360................................................. 9.1
if then else (in assembler)............................. 9.4
if then (in assembler).................................. 9.4
indirect addressing..................................... 9.6
jumps................................................... 9.4
label................................................... 9.4
linker.................................................. 9.1
loops................................................... 9.4
machine language........................................ 9.1
memory-mapped I/O....................................... 9.4
mnemonic................................................ 9.1
multiplicand............................................ 9.9
multiplication.......................................... 9.9
multiplier.............................................. 9.9
object file............................................. 9.1
object program.......................................... 9.1
offset.................................................. 9.6
optimization............................................ 9.4
packing................................................. 9.6
parameter............................................... 9.5
pointer arithmetic...................................... 9.7
pointers................................................ 9.6
procedure............................................... 9.5
product................................................. 9.9
return address.......................................... 9.5
return statement........................................ 9.5
secondary register...................................... 9.6
simulator............................................... 9.3
source file............................................. 9.1
source program.......................................... 9.1
spaghetti code.......................................... 9.4
stack................................................... 9.5
stack approach (to subprogram implementation)........... 9.5
stack pointer........................................... 9.5
structures.............................................. 9.6
subprogram.............................................. 9.5
subroutine.............................................. 9.5
symbolic debugger....................................... 9.3
unpack.................................................. 9.6
while loop (in assembler0............................... 9.4