Dictionary

Look up a word. Filter by side, by part of speech or by segment. This dictionary holds 101 A-side words and 99 B-side words: the words we learn first, not the full languages.

Search

Side	Word	Part of speech	Segment	Meaning	Example
A	MOV	Verb	Keeping values	Copy a value from one place to a different place.	mov ax, 5
A	XCHG	Verb	Keeping values	Swap the values in two places.	xchg ax, bx
A	PUSH	Verb	Keeping values	Put a value on the top of the stack.	push ax
A	POP	Verb	Keeping values	Take the value from the top of the stack.	pop ax
A	LEA	Verb	Keeping values	Calculate an address and keep the address. It does not read the memory.	lea si, [bx+4]
A	AX	Noun	Keeping values	Register A, the primary work register (16 bits). AH and AL are its two halves.	mov ax, 0
A	BX	Noun	Keeping values	Register B. It often holds a memory address.	mov al, [bx]
A	CX	Noun	Keeping values	Register C, the counter. LOOP and REP count down with it.	mov cx, 10
A	DX	Noun	Keeping values	Register D. It holds the high half of large results, and port numbers.	mov dx, 3DAh
A	SI	Noun	Keeping values	Source index. It points to the place where data comes from.	mov si, map
A	DI	Noun	Keeping values	Destination index. It points to the place where data goes.	xor di, di
A	BP	Noun	Keeping values	Base pointer. It points into the stack.	mov bp, sp
A	SP	Noun	Keeping values	Stack pointer. It points to the top of the stack.
A	DS	Noun	Keeping values	Data segment. It selects the 64 KB area that holds the data.
A	ES	Noun	Keeping values	Extra segment. It selects a second area, for example the screen memory.	mov es, ax
A	CS	Noun	Keeping values	Code segment. It selects the area that holds the instructions.
A	SS	Noun	Keeping values	Stack segment. It selects the area that holds the stack.
A	stack	Noun	Keeping values	A pile of values in memory. The last value in is the first value out.	push ax
A	[ ]	Grammar mark	Keeping values	Square brackets mean "the value at this address", not the address.	mov al, [bx]
A	BYTE	Adjective	Keeping values	Size: 8 bits, one value from 0 to 255.	mov byte [bx], 7
A	WORD	Adjective	Keeping values	Size: 16 bits, one value from 0 to 65,535.	mov word [score], 0
A	DB	Note to the translator	Keeping values	Define bytes. Put these bytes in the program file.	msg db 'Hello$'
A	DW	Note to the translator	Keeping values	Define words. Put these 16-bit numbers in the program file.	score dw 0
A	RESB	Note to the translator	Keeping values	Reserve bytes. Keep this much empty space.	buffer resb 64000
A	EQU	Note to the translator	Keeping values	Give a name to a number.	WIDTH equ 320
A	XLAT	Verb	Keeping values	Table lookup: replace AL with the byte at [BX + AL]. One verb reads one entry of a table.	mov bx, speeds xlat
A	ADD	Verb	Doing arithmetic	Add a value.	add ax, bx
A	SUB	Verb	Doing arithmetic	Subtract a value.	sub ax, 1
A	INC	Verb	Doing arithmetic	Add 1.	inc cx
A	DEC	Verb	Doing arithmetic	Subtract 1.	dec cx
A	MUL	Verb	Doing arithmetic	Multiply numbers that have no sign. The result goes in DX and AX.	mul bx
A	IMUL	Verb	Doing arithmetic	Multiply numbers that have a sign.	imul bx
A	DIV	Verb	Doing arithmetic	Divide numbers that have no sign. AX gets the result, DX gets the remainder.	div bx
A	IDIV	Verb	Doing arithmetic	Divide numbers that have a sign.	idiv bx
A	NEG	Verb	Doing arithmetic	Change the sign. 5 becomes -5.	neg ax
A	SHL	Verb	Doing arithmetic	Move the bits left. Each step multiplies by 2.	shl ax, 1
A	SHR	Verb	Doing arithmetic	Move the bits right. Each step divides by 2 (numbers with no sign).	shr ax, 1
A	SAR	Verb	Doing arithmetic	Move the bits right and keep the sign. Each step divides a signed number by 2.	sar ax, 1
A	AND	Verb	Doing arithmetic	Keep only the bits that are 1 in the two values.	and al, 0Fh
A	OR	Verb	Doing arithmetic	Set each bit that is 1 in one value or the other.	or al, 80h
A	XOR	Verb	Doing arithmetic	Flip the bits where the two values differ. xor ax, ax sets AX to 0.	xor ax, ax
A	NOT	Verb	Doing arithmetic	Flip every bit.	not al
A	ADC	Verb	Doing arithmetic	Add, plus the carry flag. It joins the high bytes of a number that is longer than one register.	adc al, 0
A	SBB	Verb	Doing arithmetic	Subtract, minus the carry flag (the borrow). The partner of ADC.	sbb al, 0
A	DAA	Verb	Doing arithmetic	Decimal adjust after an ADD or ADC of two packed decimal bytes in AL. It makes 09h + 1 into 10h and sets CF after 99.	add al, 1 daa
A	DAS	Verb	Doing arithmetic	Decimal adjust after a SUB or SBB of two packed decimal bytes in AL. The partner of DAA.	sub al, 1 das
A	AAM	Verb	Doing arithmetic	Divide AL by 10. The tens go to AH, the units stay in AL: a ready-made step to show a number under 100.	aam
A	CBW / CWD	Verb	Doing arithmetic	Make a signed number longer: CBW copies the sign of AL into AH. CWD copies the sign of AX into DX, before IDIV.	cwd idiv cx
A	CF	Noun	Doing arithmetic	Carry flag. It is 1 when a result is too large for its size.
A	CMP	Verb	Making choices and repeating	Compare two values. It subtracts but keeps only the flags.	cmp ax, 10
A	TEST	Verb	Making choices and repeating	Compare the bits of two values. It does an AND but keeps only the flags.	test al, 8
A	JMP	Verb	Making choices and repeating	Go to a label.	jmp game_loop
A	JE / JZ	Verb	Making choices and repeating	Go to a label if the compared values are equal (the zero flag is 1).	je no_fuel
A	JNE / JNZ	Verb	Making choices and repeating	Go to a label if the compared values are not equal.	jne again
A	JL / JG	Verb	Making choices and repeating	Go to a label if less / greater (numbers with a sign).	jl too_low
A	JB / JA	Verb	Making choices and repeating	Go to a label if below / above (numbers with no sign).	jb too_low
A	LOOP	Verb	Making choices and repeating	Subtract 1 from CX. If CX is not 0, go to the label.	loop again
A	CALL	Verb	Making choices and repeating	Go to a subroutine and remember the return address.	call draw_ship
A	RET	Verb	Making choices and repeating	Return to the instruction after the CALL.	ret
A	ZF	Noun	Making choices and repeating	Zero flag. It is 1 when the last result is zero.
A	SF	Noun	Making choices and repeating	Sign flag. It is 1 when the last result is negative.
A	label:	Grammar mark	Making choices and repeating	A name for a place in the program. A colon ends it.	again:
A	REP	Adverb	Working with many values	Do the next string verb again, CX times.	rep stosb
A	MOVSB	Verb	Working with many values	Copy one byte from DS:SI to ES:DI, then move SI and DI to the next byte.	rep movsb
A	MOVSW	Verb	Working with many values	Copy one word (2 bytes) from DS:SI to ES:DI.	rep movsw
A	STOSB	Verb	Working with many values	Put AL at ES:DI, then move DI to the next byte.	rep stosb
A	STOSW	Verb	Working with many values	Put AX at ES:DI, then move DI 2 bytes.	rep stosw
A	LODSB	Verb	Working with many values	Load the byte at DS:SI into AL, then move SI.	lodsb
A	CLD	Verb	Working with many values	Make the string verbs move forward (clear the direction flag).	cld
A	DF	Noun	Working with many values	Direction flag. It sets the direction of the string verbs.
A	ORG	Note to the translator	Organizing a program	Tell the assembler the start address of the program. A DOS .COM program starts at 100h.	org 100h
A	BITS	Note to the translator	Organizing a program	Select 16-bit or 32-bit translation.	bits 16
A	SECTION	Note to the translator	Organizing a program	Put the next lines in a named part of the file, for code or for data.	section .data
A	%define	Note to the translator	Organizing a program	Give a name to a piece of text.	%define SCREEN 0A000h
A	%macro	Note to the translator	Organizing a program	Give a name to a group of instructions. Then use the name as one word.	%macro wait_key 0
A	%include	Note to the translator	Organizing a program	Read a different file at this point.	%include "vga.inc"
A	TIMES	Note to the translator	Organizing a program	Do the rest of the line again, a number of times.	times 10 db 0
A	INCBIN	Note to the translator	Organizing a program	Put the bytes of a file into the program at this place. This is how the A side reads a table that the B side made.	sine_table: incbin "sine.bin"
A	;	Grammar mark	Organizing a program	Starts a comment. The assembler ignores the rest of the line.	; draw the ship
A	,	Grammar mark	Organizing a program	Separates the destination (first) from the source (second).	mov ax, bx
A	h	Grammar mark	Organizing a program	At the end of a number, h marks base 16 (hexadecimal). 10h is 16.	mov ax, 13h
A	INT	Verb	Showing text and reading keys	Call a service of the BIOS or DOS (a ready-made routine in the computer).	int 21h
A	INT 21h, AH=09h	Idiom	Showing text and reading keys	DOS: show the text at DS:DX. A $ sign marks the end of the text.	mov ah, 09h
A	INT 21h, AH=02h	Idiom	Showing text and reading keys	DOS: show one character. The character is in DL.	mov ah, 02h
A	INT 21h, AH=4Ch	Idiom	Showing text and reading keys	DOS: stop the program and return to DOS.	mov ax, 4C00h
A	INT 16h, AH=00h	Idiom	Showing text and reading keys	BIOS: wait for a key. The BIOS puts the key code in AX.	mov ah, 0
A	INT 16h, AH=01h	Idiom	Showing text and reading keys	BIOS: tell if a key is ready, without a wait.	mov ah, 1
A	INT 10h, AX=0013h	Idiom	Showing text and reading keys	BIOS: change the screen to 320 x 200 pixels with 256 colors (Mode 13h).	mov ax, 13h
A	INT 10h, AX=0003h	Idiom	Showing text and reading keys	BIOS: change the screen to text mode again.	mov ax, 3
A	IN	Verb	Controlling the hardware	Read a value from a hardware port.	in al, dx
A	OUT	Verb	Controlling the hardware	Write a value to a hardware port.	out dx, al
A	CLI	Verb	Controlling the hardware	Stop hardware interrupts for a short time.	cli
A	STI	Verb	Controlling the hardware	Let hardware interrupts start again.	sti
A	IRET	Verb	Controlling the hardware	Return from an interrupt handler.	iret
A	HLT	Verb	Controlling the hardware	Stop the processor until the next interrupt.	hlt
A	port	Noun	Controlling the hardware	A numbered door to a hardware device. The processor talks to devices through ports.	in al, 60h
A	interrupt	Noun	Controlling the hardware	A signal that stops the program for a moment, runs a handler, then lets the program continue.
A	A000h	Noun	Controlling the hardware	The segment of the VGA screen memory in Mode 13h. Each byte is one pixel.	mov ax, 0A000h
A	3DAh	Noun	Controlling the hardware	The VGA status port. Bit 3 is 1 while the screen beam returns to the top (vertical retrace).	mov dx, 3DAh
A	3C8h / 3C9h	Noun	Controlling the hardware	The VGA palette ports. Select a color number, then write its red, green and blue parts.	mov dx, 3C8h
A	INT 09h	Noun	Controlling the hardware	The keyboard interrupt. A game replaces its handler to read keys fast.
B	INTEGER	Noun	Keeping values	A whole number, for example -1, 0 or 42.	integer :: lives
B	REAL	Noun	Keeping values	A number with a decimal point, for example 3.14.	real :: speed
B	LOGICAL	Noun	Keeping values	A value that is true or false.	logical :: landed
B	CHARACTER	Noun	Keeping values	Text.	character(len=20) :: name
B	COMPLEX	Noun	Keeping values	A complex number: a real part and an imaginary part.	complex :: z
B	TYPE	Noun	Keeping values	A new noun that you make from other nouns (a derived type).	type :: ship
B	::	Grammar mark	Keeping values	Separates the description from the names in a declaration.	real :: x, y
B	=	Grammar mark	Keeping values	Put the value on the right into the name on the left. It is not the maths "equals".	x = x + 1
B	PARAMETER	Adjective	Keeping values	The value never changes (a constant).	real, parameter :: g = 1.62
B	DIMENSION	Adjective	Keeping values	This name holds a list or a table of values (an array).	real, dimension(100) :: x
B	ALLOCATABLE	Adjective	Keeping values	The program sets the size of this array when it runs.	real, allocatable :: x(:)
B	POINTER	Adjective	Keeping values	This name points to a different value.	real, pointer :: p
B	TARGET	Adjective	Keeping values	A pointer can point to this value.	real, target :: t
B	SAVE	Adjective	Keeping values	Keep this value between calls.	integer, save :: count
B	KIND	Adjective	Keeping values	Select the precision: how many digits a number keeps.	real(kind=real64) :: t
B	INT8 / INT16	Adjective	Keeping values	A kind name from ISO_FORTRAN_ENV: a whole number of exactly 1 or 2 bytes. The same size as a BYTE or a WORD on the A side.	integer(int16) :: table(0:255)
B	REAL64	Adjective	Keeping values	A kind name from ISO_FORTRAN_ENV: a decimal-point number of 8 bytes (double precision).	real(real64) :: theta
B	ALLOCATE	Verb	Keeping values	Make space for an ALLOCATABLE array.	allocate(x(n))
B	DEALLOCATE	Verb	Keeping values	Release the space of an array.	deallocate(x)
B	+ -	Grammar mark	Doing arithmetic	Add and subtract.	v = v + a*dt
B	* /	Grammar mark	Doing arithmetic	Multiply and divide. A division of two whole numbers drops the fraction: 7/2 is 3.	half = total / 2
B	**	Grammar mark	Doing arithmetic	Raise to a power. x**2 is x times x.	e = 0.5*m*v**2
B	( )	Grammar mark	Doing arithmetic	Group a part of a formula, as in maths.	a = (b + c) * d
B	SQRT	Idiom	Doing arithmetic	Square root.	r = sqrt(x**2 + y**2)
B	ABS	Idiom	Doing arithmetic	The size of a number without its sign.	d = abs(x - y)
B	SIN / COS	Idiom	Doing arithmetic	Sine and cosine. The angle is in radians.	vx = v*cos(angle)
B	ATAN2	Idiom	Doing arithmetic	The angle of a point (y, x).	angle = atan2(y, x)
B	EXP / LOG	Idiom	Doing arithmetic	The exponential and the natural logarithm.	p = exp(-t/tau)
B	MOD	Idiom	Doing arithmetic	The remainder after a division.	frame = mod(tick, 4)
B	MAX / MIN	Idiom	Doing arithmetic	The largest / smallest of the values.	fuel = max(fuel, 0.0)
B	NINT	Idiom	Doing arithmetic	Round to the nearest whole number.	px = nint(x)
B	FLOOR	Idiom	Doing arithmetic	Round down to a whole number.	row = floor(y)
B	REAL( )	Idiom	Doing arithmetic	Change a whole number into a REAL.	avg = real(total) / n
B	INT( )	Idiom	Doing arithmetic	Change a REAL into a whole number. It drops the fraction.	i = int(x)
B	MODULO	Idiom	Doing arithmetic	The remainder that wraps around, never negative: modulo(-1, 256) is 255. MOD keeps the sign: mod(-1, 256) is -1. A byte register on the A side wraps like MODULO.	z = table(modulo(t + 64, 256))
B	IAND	Idiom	Doing arithmetic	Bitwise AND: keep only the bits that are 1 in both numbers. The same job as AND on the A side.	byte = iand(v, 255)
B	ISHFT / SHIFTA	Idiom	Doing arithmetic	Move the bits of a whole number. SHIFTA moves right and keeps the sign, as SAR does. ISHFT fills with zeros, as SHL and SHR do.	y = shifta(s * 64, 8)
B	RANDOM_NUMBER	Idiom	Doing arithmetic	Fill a value or an array with random numbers from 0 to 1. The laboratory uses it to make a terrain.	call random_number(r)
B	IF ... THEN ... END IF	Verb	Making choices and repeating	Do a block only if a condition is true.	if (fuel <= 0.0) then
B	ELSE	Grammar mark	Making choices and repeating	Starts the block to do when the condition is false.	else
B	SELECT CASE	Verb	Making choices and repeating	Choose one block from many, by the value of one name.	select case (key)
B	DO	Verb	Making choices and repeating	Do a block again, a number of times.	do i = 1, 10
B	DO WHILE	Verb	Making choices and repeating	Do a block again while a condition is true.	do while (.not. landed)
B	EXIT	Verb	Making choices and repeating	Stop the loop now.	exit
B	CYCLE	Verb	Making choices and repeating	Go to the next turn of the loop.	cycle
B	STOP	Verb	Making choices and repeating	Stop the program.	stop
B	ERROR STOP	Verb	Making choices and repeating	Stop the program and report a failure. The build script sees the failure and stops. This is how a check says no.	if (mismatches /= 0) error stop 'The A side and the B side disagree.'
B	BTEST	Idiom	Making choices and repeating	Is one bit of a whole number 1? The same question as TEST on the A side.	if (btest(flags, 3)) then
B	MERGE	Idiom	Making choices and repeating	Choose the first value when the condition is true, or the second when it is false. One idiom replaces an IF block.	merge('true ', 'false', ok)
B	== /= < > <= >=	Grammar mark	Making choices and repeating	Compare two values: equal, not equal, less, greater, less or equal, greater or equal.	if (x /= 0) then
B	.and. .or. .not.	Grammar mark	Making choices and repeating	Join or reverse conditions.	if (a .and. .not. b) then
B	x(:)	Grammar mark	Working with many values	All the values of the array x.	x(:) = 0.0
B	x(2:5)	Grammar mark	Working with many values	The values of x from position 2 to position 5.	y = x(2:5)
B	WHERE	Verb	Working with many values	Change only the values that meet a condition.	where (x < 0.0) x = 0.0
B	CONCURRENT	Adverb	Working with many values	In DO CONCURRENT: the steps can happen in any order, so the compiler can do them at the same time.	do concurrent (i = 1:n)
B	SUM	Idiom	Working with many values	Add all the values.	total = sum(scores)
B	PRODUCT	Idiom	Working with many values	Multiply all the values.	p = product(x)
B	MAXVAL / MINVAL	Idiom	Working with many values	The largest / smallest value.	best = maxval(scores)
B	MAXLOC	Idiom	Working with many values	The position of the largest value.	i = maxloc(scores, 1)
B	COUNT	Idiom	Working with many values	How many values meet a condition.	n = count(alive)
B	ANY / ALL	Idiom	Working with many values	True if one value / all values meet a condition.	if (any(hit)) then
B	SIZE	Idiom	Working with many values	How many values an array holds.	n = size(x)
B	DOT_PRODUCT	Idiom	Working with many values	Multiply two lists value by value, then add the results.	d = dot_product(a, b)
B	MATMUL	Idiom	Working with many values	Multiply two matrices (tables of numbers).	p2 = matmul(rot, p)
B	TRANSPOSE	Idiom	Working with many values	Turn the rows of a table into columns.	t = transpose(m)
B	RESHAPE	Idiom	Working with many values	Give the same values a different shape.	m = reshape(v, [2, 2])
B	PROGRAM	Note to the translator	Organizing a program	The start of the primary program.	program lander
B	END	Note to the translator	Organizing a program	The end of a program, module, subroutine or function.	end program lander
B	MODULE	Note to the translator	Organizing a program	A named box of related names and procedures.	module physics
B	USE	Note to the translator	Organizing a program	Make the names in a module available here.	use physics
B	CONTAINS	Note to the translator	Organizing a program	The procedures come after this line.	contains
B	SUBROUTINE	Note to the translator	Organizing a program	A named procedure that does a job.	subroutine draw(ship)
B	FUNCTION	Note to the translator	Organizing a program	A named procedure that returns one value.	function speed(v)
B	IMPLICIT NONE	Note to the translator	Organizing a program	Every name must have a declared type. Without it, old Fortran guesses the type from the first letter.	implicit none
B	CALL	Verb	Organizing a program	Run a subroutine.	call draw(ship)
B	INTENT(IN)	Adjective	Organizing a program	This argument comes in, and the procedure must not change it.	real, intent(in) :: dt
B	INTENT(OUT)	Adjective	Organizing a program	The procedure gives this argument its value.	real, intent(out) :: v2
B	PURE	Adjective	Organizing a program	This procedure changes nothing outside itself.	pure function f(x)
B	ELEMENTAL	Adjective	Organizing a program	Write the procedure for one value. Fortran then applies it to each value of an array.	elemental function f(x)
B	PRIVATE / PUBLIC	Adjective	Organizing a program	Hide a name inside its module, or show it to other code.	private :: helper
B	!	Grammar mark	Organizing a program	Starts a comment. The compiler ignores the rest of the line.	! gravity of the Moon
B	&	Grammar mark	Organizing a program	The statement continues on the next line.	x = a + b + &
B	PRINT	Verb	Showing text and reading keys	Show values on the screen.	print *, "Fuel:", fuel
B	WRITE	Verb	Showing text and reading keys	Write values to the screen or to a file.	write(*, '(F8.2)') fuel
B	READ	Verb	Showing text and reading keys	Read values from the keyboard or from a file.	read *, thrust
B	OPEN	Verb	Showing text and reading keys	Connect a file to a unit number.	open(newunit=u, file='map.dat')
B	CLOSE	Verb	Showing text and reading keys	Disconnect a file.	close(u)
B	NEWUNIT=	Grammar mark	Showing text and reading keys	In OPEN: let the compiler choose a free unit number and put it in the name.	open(newunit=u, file='sine.bin')
B	ACCESS='STREAM'	Grammar mark	Showing text and reading keys	In OPEN: read or write the raw bytes of a file, with no record marks. This is how the B side writes a table for the A side.	open(newunit=u, file='sine.bin', access='stream', form='unformatted')
B	'(I4.4)' / '(I0)'	Grammar mark	Showing text and reading keys	Two formats for a whole number. I4.4 keeps the leading zeros (0042), for a countdown. I0 removes them (42), for a score.	print '(i4.4)', fuel
B	GET_COMMAND_ARGUMENT	Idiom	Showing text and reading keys	Read one word that the person typed after the program name. The checker gets the file name this way.	call get_command_argument(1, in_file)
B	*	Grammar mark	Showing text and reading keys	In PRINT and READ: let Fortran choose the layout.	print *, x
B	'(F8.2)'	Grammar mark	Showing text and reading keys	A layout pattern. F8.2 is a number 8 characters wide with 2 decimals.	write(*, '(F8.2)') x
B	ISO_C_BINDING	Note to the translator	Controlling the hardware	A built-in module with the words to talk to C code, and through C, to the hardware.	use iso_c_binding
B	BIND(C)	Adjective	Controlling the hardware	Make this procedure or type match the layout of the C language.	subroutine vsync() bind(c)
B	ISO_FORTRAN_ENV	Note to the translator	Controlling the hardware	A built-in module with exact sizes, for example INT32 and REAL64.	use iso_fortran_env
B	SYSTEM_CLOCK	Idiom	Controlling the hardware	Read the count of clock ticks.	call system_clock(t0)
B	CPU_TIME	Idiom	Controlling the hardware	Read the processor time that the program used.	call cpu_time(t)
B	EXECUTE_COMMAND_LINE	Idiom	Controlling the hardware	Ask the operating system to run a command.	call execute_command_line('ls')