VHDL quick ref.

+ some Vanilla info.
1076:1987 
PACKAGE package_name IS
	TYPE my_enumeration_type IS(enum1, enum2, ... );		--enumeration type

	TYPE type IS RANGE x TO y;					--value type

	TYPE cons_array IS ARRAY(7 DOWNTO 0) OF type;			--constrained array
	TYPE uncons_array IS ARRAY(INTEGER RANGE <>) OF type;	--unconstrained array

	TYPE my_record IS RECORD					--record type
		record_1: type_a;
		record_2: type_b;
	END RECORD;

	CONSTANT constant_1: type := value;				--constant declaration
	CONSTANT constant_2: uncons_array(0 TO 16) := (1, 2, 3, other => 4);

	PROCEDURE procedure_name(x :IN type; y :OUT type);		--subprogram declaration
	FUNCTION function_name(a, b, c: type) RETURN d;
END package_name;

PACKAGE BODY package_name IS
	PROCEDURE procedure_name(x :IN type; y :OUT type) IS
		--declarations
	BEGIN
		--statements
	END procedure_name;

	FUNCTION function_name(a, b, c:type) RETURN d IS
		--declarations
	BEGIN
		--statements
		RETURN d;
	END function_name;
END package_name;

LIBRARY library_name;
USE library_name.package_name.all;

ENTITY entity_name IS
	GENERIC (generic_name :type := value);
	PORT(a :IN type_a;
		b :OUT type_b := value;
		c, d :INOUT type);
END entity_name;

ARCHITECTURE architecture_name OF entity_name IS
	COMPONENT component_name
		GENERIC(...);
		PORT(...);
	END COMPONENT;

	--signal declarations
BEGIN
	component_label: component_name
		GENERIC MAP(..=>..);
		PORT MAP(..&=>..);
	
	process_name :PROCESS (sensitivity_list)
		--declarations - variables
	BEGIN
		--sequential statements
		--if there is no sensitivity_list then there must be WAIT statements
			WAIT; 
			WAIT ON waiting_sensitivity_list; 
			WAIT FOR time;
			WAIT UNTIL waiting_condition;

		signal <= new_value AFTER delay;
		signal2 <= new_value1 AFTER delay1, new_value2 AFTER delay2;

		variable := new_value;

		CASE variable IS
			WHEN value1 =>
				--sequential statements
			WHEN value2 | value3 | value4 TO value8 =>
				--
			WHEN OTHERS =>
				NULL;
		END CASE;

		IF expression THEN
			--sequential statements
		ELSIF expression THEN
			--
		ELSE
			--
		END IF;

		FOR variable IN x TO y LOOP
			--sequential statements
			exit;						--exit loop early
			--
		END LOOP;

		WHILE expression LOOP
			--sequential statements
		END LOOP;

		ASSERT variable'attribute
			REPORT "message" SEVERITY severity_level;
				--severity_level = NOTE, WARNING, ERROR or FAILURE
	END PROCESS process_name;

	signal1 <= new_value AFTER time;				--concurrent signal assignments
	signal2 <= new_value AFTER time;

END architecture_name;

CONFIGURATION config_name OF entity_name IS
	FOR architecture_name
		FOR ALL: component_name
			USE ENTITY library.entity_name(architecture_name);
		END FOR;
	END FOR;
END config_name;
Attributes, Expressions and operators, etc 
	Array attributes := 'LEFT, 'RIGHT, 'HIGH, 'LOW, 'RANGE, 'REVERSE_RANGE, 'LENGTH
	Type attributes := 'BASE, 'LEFT, 'RIGHT, 'HIGH, 'LOW(v), 'POS(p), 'VAL(v), 'SUCC(v), 
				'PRED(v), 'LEFTOF(v), 'RIGHTOF(v)
		--p = position, v = value
	Signal attributes := 'DELAYED(time), 'STABLE(time), 'EVENT, 'LAST_EVENT, 'LAST_VALUE, 
				'QUIET(time), 'ACTIVE, 'LAST_ACTIVE, 'TRANSACTION

	array_name(index)
	array_name(x TO/DOWNTO y)

	()	typename()
	**	ABS	NOT
	*	/	MOD	REM
	+	-	&
	=	/=	<	<=	>	>=
	AND	OR	XOR	NAND	NOR
Reserved words 
ABS	ACCESS	AFTER	ALIAS	ALL	AND	ARCHITECTURE	ARRAY	ASSERT	ATTRIBUTE
BEGIN	BLOCK	BODY	BUFFER	BUS	CASE	COMPONENS	CONFIGURATION	CONSTANT
DISCONNECT	DOWNTO	ELSE	ELSIF	END	ENTITY	EXIT	FILE	FOR	FUNCTION
GENERATE	GENERIC	GUARDED	IF	IN	INOUT	IS	LABEL	LIBRARY	LINKAGE
LOOP	MAP	MOD	NAND	NEW	NEXT	NOR	NOT	NULL	OF	ON
OPEN	OR	OTHERS	OUT	PACKAGE	PORT	PROCEDURE	PROCESS	RANGE	RECORD
REGISTER	REM	REPORT	RETURN	SELECT	SEVERITY	SIGNAL	SUBTYPE	THEN
TO	TRANSPORT	TYPE	UNITS	UNTIL	USE	VARIABLE	WAIT	WHEN
WHILE	WITH	XOR
Packages 
PACKAGE STANDARD IS		--(Library standard)
	TYPE BOOLEAN IS (FALSE, TRUE);
	TYPE BIT IS ('0','1');
	TYPE CHARACTER IS (...);
	TYPE SEVERITY_LEVEL IS (NOTE, WARNING, ERROR, FAILURE);
	TYPE INTEGER IS RANGE implementation specific;
	TYPE REAL IS RANGE implementation specific;
	TYPE TIME IS RANGE implementation specific
		UNITS
			FS;	PS = 1000 FS;	NS = 1000 PS;	US = 1000 NS;
			MS = 1000 US;	SEC = 1000 MS;	MIN = 60 SEC; HR = 60 MIN;
		END UNITS;
	FUNCTION NOW RETURN TIME;
	SUBTYPE NATURAL IS INTEGER RANGE 0 TO INTEGER'HIGH;
	SUBTYPE POSITIVE IS INTEGER RANGE 1 TO INTEGER'HIGH;
	TYPE STRING IS ARRAY (POSITIVE RANGE <>) OF CHARACTER;
	TYPE BIT_VECTOR IS ARRAY (NATURAL RANGE <>) OF BIT;
END STANDARD;

PACKAGE TEXTIO IS		--(Library standard)
	TYPE LINE IS ACCESS STRING;
	TYPE TEXT IS FILE OF STRING;
	TYPE SIDE IS (RIGHT, LEFT);
	SUBTYPE WIDTH IS NATURAL;
	FILE INPUT: TEXT IS IN "STD_INPUT";
	FILE OUTPUT: TEXT IS OUT "STD_OUTPUT";
	PROCEDURE READLINE( var :IN TEXT; var2 :INOUT LINE);
	PROCEDURE READ( var :INOUT LINE; value :OUT {BIT, BIT_VECTOR, BOOLEAN, 
					CHARACTER, INTEGER, REAL, STRING, TIME});
	PROCEDURE WRITELINE( var :OUT TEXT; var2 :INOUT LINE);
	PROCEDURE WRITE(var :INOUT LINE; value :IN {BIT, BIT_VECTOR, BOOLEAN,
					CHARACTER, INTEGER, REAL, STRING, TIME});
END TEXTIO;

Vanilla info.


Last modified 20/6/97