nvram_map_gen.awk

#!/usr/bin/awk -f

#-
# Copyright (c) 2015-2016 Landon Fuller <[email protected]>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer,
#    without modification.
# 2. Redistributions in binary form must reproduce at minimum a disclaimer
#    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
#    redistribution must be conditioned upon including a substantially
#    similar Disclaimer requirement for further binary redistribution.
#
# NO WARRANTY
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
# THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGES.
# 

BEGIN	{ main() }
END	{ at_exit() }

#
# Print usage
#
function usage() {
	print "usage: bhnd_nvram_map.awk <input map> [-hd] [-o output file]"
	_EARLY_EXIT = 1
	exit 1
}

function main(_i) {
	RS="\n"

	OUTPUT_FILE = null

	# Probe awk implementation's hex digit handling
	if ("0xA" + 0 != 10) {
		AWK_REQ_HEX_PARSING=1
	}

	# Output type
	OUT_T = null
	OUT_T_HEADER = "HEADER"
	OUT_T_DATA = "DATA"
	VERBOSE = 0

	# Tab width to use when calculating output alignment
	TAB_WIDTH = 8

	# Enable debug output
	DEBUG = 0

	# Maximum revision
	REV_MAX = 256

	# Parse arguments
	if (ARGC < 2)
		usage()

	for (_i = 1; _i < ARGC; _i++) {
		if (ARGV[_i] == "--debug") {
			DEBUG = 1
		} else if (ARGV[_i] == "-d" && OUT_T == null) {
			OUT_T = OUT_T_DATA
		} else if (ARGV[_i] == "-h" && OUT_T == null) {
			OUT_T = OUT_T_HEADER
		} else if (ARGV[_i] == "-v") {
		        VERBOSE = 1
		} else if (ARGV[_i] == "-o") {
			_i++
			if (_i >= ARGC)
				usage()

			OUTPUT_FILE = ARGV[_i]
		} else if (ARGV[_i] == "--") {
			_i++
			break
		} else if (ARGV[_i] !~ /^-/) {
			FILENAME = ARGV[_i]
		} else {
			print "unknown option " ARGV[_i]
			usage()
		}
	}

	ARGC=2

	if (OUT_T == null) {
		print("error: one of -d or -h required")
		usage()
	}

	if (FILENAME == null) {
		print("error: no input file specified")
		usage()
	}

	if (OUTPUT_FILE == "-") {
		OUTPUT_FILE = "/dev/stdout"
	} else if (OUTPUT_FILE == null) {
		OUTPUT_FILE_IDX = split(FILENAME, _g_output_path, "/")
		OUTPUT_FILE = _g_output_path[OUTPUT_FILE_IDX]

		if (OUTPUT_FILE !~ /^bhnd_/)
			OUTPUT_FILE = "bhnd_" OUTPUT_FILE

		if (OUT_T == OUT_T_HEADER)
			OUTPUT_FILE = OUTPUT_FILE ".h" 
		else
			OUTPUT_FILE = OUTPUT_FILE "_data.h"
	}

	# Common Regexs
	UINT_REGEX	= "^(0|[1-9][0-9]*)$"
	HEX_REGEX	= "^(0x[A-Fa-f0-9]+)$"
	OFF_REGEX	= "^(0|[1-9][0-9]*)|^(0x[A-Fa-f0-9]+)"
	REL_OFF_REGEX	= "^\\+(0|[1-9][0-9]*)|^\\+(0x[A-Fa-f0-9]+)"

	ARRAY_REGEX	= "\\[(0|[1-9][0-9]*)\\]"
	TYPES_REGEX	= "^(((u|i)(8|16|32))|char)("ARRAY_REGEX")?$"

	IDENT_REGEX		= "[A-Za-z_][A-Za-z0-9_]*"
	SVAR_IDENT_REGEX	= "^<"IDENT_REGEX">{?$"	# <var> identifiers
	VAR_IDENT_REGEX		= "^"IDENT_REGEX"{?$"	# var identifiers

	VACCESS_REGEX	= "^(private|internal)$"

	# Property array keys
	PROP_ID		= "p_id"
	PROP_NAME	= "p_name"

	# Prop path array keys
	PPATH_HEAD	= "ppath_head"
	PPATH_TAIL	= "ppath_tail"

	# Object array keys
	OBJ_IS_CLS	= "o_is_cls"
	OBJ_SUPER	= "o_super"
	OBJ_PROP	= "o_prop"

	# Class array keys
	CLS_NAME	= "cls_name"
	CLS_PROP	= "cls_prop"

	# C SPROM binding opcodes/opcode flags
	SPROM_OPCODE_EOF		= "SPROM_OPCODE_EOF"
	SPROM_OPCODE_NELEM		= "SPROM_OPCODE_NELEM"
	SPROM_OPCODE_VAR_END		= "SPROM_OPCODE_VAR_END"
	SPROM_OPCODE_VAR_IMM		= "SPROM_OPCODE_VAR_IMM"
	SPROM_OPCODE_VAR_REL_IMM	= "SPROM_OPCODE_VAR_REL_IMM"
	SPROM_OPCODE_VAR		= "SPROM_OPCODE_VAR"
	SPROM_OPCODE_REV_IMM		= "SPROM_OPCODE_REV_IMM"
	SPROM_OPCODE_REV_RANGE		= "SPROM_OPCODE_REV_RANGE"
	  SPROM_OP_REV_START_MASK	= "SPROM_OP_REV_START_MASK"
	  SPROM_OP_REV_START_SHIFT	= "SPROM_OP_REV_START_SHIFT"
	  SPROM_OP_REV_END_MASK		= "SPROM_OP_REV_END_MASK"
	  SPROM_OP_REV_END_SHIFT	= "SPROM_OP_REV_END_SHIFT"
	SPROM_OPCODE_MASK_IMM		= "SPROM_OPCODE_MASK_IMM"
	SPROM_OPCODE_MASK		= "SPROM_OPCODE_MASK"
	SPROM_OPCODE_SHIFT_IMM		= "SPROM_OPCODE_SHIFT_IMM"
	SPROM_OPCODE_SHIFT		= "SPROM_OPCODE_SHIFT"
	SPROM_OPCODE_OFFSET_REL_IMM	= "SPROM_OPCODE_OFFSET_REL_IMM"
	SPROM_OPCODE_OFFSET		= "SPROM_OPCODE_OFFSET"
	SPROM_OPCODE_TYPE		= "SPROM_OPCODE_TYPE"
	SPROM_OPCODE_TYPE_IMM		= "SPROM_OPCODE_TYPE_IMM"
	SPROM_OPCODE_DO_BINDN_IMM	= "SPROM_OPCODE_DO_BINDN_IMM"
	SPROM_OPCODE_DO_BIND		= "SPROM_OPCODE_DO_BIND"
	SPROM_OPCODE_DO_BINDN		= "SPROM_OPCODE_DO_BINDN"
	  SPROM_OP_BIND_SKIP_IN_MASK	= "SPROM_OP_BIND_SKIP_IN_MASK"
	  SPROM_OP_BIND_SKIP_IN_SHIFT	= "SPROM_OP_BIND_SKIP_IN_SHIFT"
	  SPROM_OP_BIND_SKIP_IN_SIGN	= "SPROM_OP_BIND_SKIP_IN_SIGN"
	  SPROM_OP_BIND_SKIP_OUT_MASK	= "SPROM_OP_BIND_SKIP_OUT_MASK"
	  SPROM_OP_BIND_SKIP_OUT_SHIFT	= "SPROM_OP_BIND_SKIP_OUT_SHIFT"

	SPROM_OP_DATA_U8		= "SPROM_OP_DATA_U8"
	SPROM_OP_DATA_U8_SCALED		= "SPROM_OP_DATA_U8_SCALED"
	SPROM_OP_DATA_U16		= "SPROM_OP_DATA_U16"
	SPROM_OP_DATA_U32		= "SPROM_OP_DATA_U32"
	SPROM_OP_DATA_I8		= "SPROM_OP_DATA_I8"

	SPROM_OP_BIND_SKIP_IN_MAX	=  3	# maximum SKIP_IN value
	SPROM_OP_BIND_SKIP_IN_MIN	= -3	# minimum SKIP_IN value
	SPROM_OP_BIND_SKIP_OUT_MAX	=  1	# maximum SKIP_OUT value
	SPROM_OP_BIND_SKIP_OUT_MIN	=  0	# minimum SKIP_OUT value
	SPROM_OP_IMM_MAX		= 15	# maximum immediate value
	SPROM_OP_REV_RANGE_MAX		= 15	# maximum SROM rev range value

	# SPROM opcode encoding state
	SromOpStream = class_new("SromOpStream")
		class_add_prop(SromOpStream, p_layout, "layout")
		class_add_prop(SromOpStream, p_revisions, "revisions")
		class_add_prop(SromOpStream, p_vid, "vid")
		class_add_prop(SromOpStream, p_offset, "offset")
		class_add_prop(SromOpStream, p_type, "type")
		class_add_prop(SromOpStream, p_nelem, "nelem")
		class_add_prop(SromOpStream, p_mask, "mask")
		class_add_prop(SromOpStream, p_shift, "shift")
		class_add_prop(SromOpStream, p_bind_total, "bind_total")
		class_add_prop(SromOpStream, p_pending_bind, "pending_bind")

	# SROM pending bind operation
	SromOpBind = class_new("SromOpBind")
		class_add_prop(SromOpBind, p_segment, "segment")
		class_add_prop(SromOpBind, p_count, "count")
		class_add_prop(SromOpBind, p_offset, "offset")
		class_add_prop(SromOpBind, p_width, "width")
		class_add_prop(SromOpBind, p_skip_in, "skip_in")
		class_add_prop(SromOpBind, p_skip_out, "skip_out")
		class_add_prop(SromOpBind, p_buffer, "buffer")

	# Map class definition
	Map = class_new("Map")

	# Array class definition
	Array = class_new("Array")
		class_add_prop(Array, p_count, "count")

	# MacroType class definition
	# Used to define a set of known macro types that may be generated
	MacroType = class_new("MacroType")
		class_add_prop(MacroType, p_name, "name")
		class_add_prop(MacroType, p_const_suffix, "const_suffix")

	MTypeVarName	= macro_type_new("name", "")		# var name
	MTypeVarID	= macro_type_new("id", "_ID")		# var unique ID
	MTypeVarMaxLen	= macro_type_new("len", "_MAXLEN")	# var max array length

	# Preprocessor Constant
	MacroDefine = class_new("MacroDefine")
		class_add_prop(MacroDefine, p_name, "name")
		class_add_prop(MacroDefine, p_value, "value")

	# ParseState definition
	ParseState = class_new("ParseState")
		class_add_prop(ParseState, p_ctx, "ctx")
		class_add_prop(ParseState, p_is_block, "is_block")
		class_add_prop(ParseState, p_line, "line")

	# Value Formats
	Fmt = class_new("Fmt")
		class_add_prop(Fmt, p_name, "name")
		class_add_prop(Fmt, p_symbol, "symbol")
		class_add_prop(Fmt, p_array_fmt, "array_fmt")

	FmtHex		= fmt_new("hex", "bhnd_nvram_val_bcm_hex_fmt")
	FmtDec 		= fmt_new("decimal", "bhnd_nvram_val_bcm_decimal_fmt")
	FmtMAC		= fmt_new("macaddr", "bhnd_nvram_val_bcm_macaddr_fmt")
	FmtLEDDC	= fmt_new("leddc", "bhnd_nvram_val_bcm_leddc_fmt")
	FmtCharArray	= fmt_new("char_array", "bhnd_nvram_val_char_array_fmt")
	FmtChar		= fmt_new("char", "bhnd_nvram_val_char_array_fmt",
			      FmtCharArray)
	FmtStr		= fmt_new("string", "bhnd_nvram_val_bcm_string_fmt")

	# User-specifiable value formats
	ValueFormats = map_new()
		map_set(ValueFormats, get(FmtHex,	p_name), FmtHex)
		map_set(ValueFormats, get(FmtDec,	p_name), FmtDec)
		map_set(ValueFormats, get(FmtMAC,	p_name), FmtMAC)
		map_set(ValueFormats, get(FmtLEDDC,	p_name), FmtLEDDC)
		map_set(ValueFormats, get(FmtStr,	p_name), FmtStr)

	# Data Types
	Type = class_new("Type")
		class_add_prop(Type, p_name, "name")
		class_add_prop(Type, p_width, "width")
		class_add_prop(Type, p_signed, "signed")
		class_add_prop(Type, p_const, "const")
		class_add_prop(Type, p_const_val, "const_val")
		class_add_prop(Type, p_array_const, "array_const")
		class_add_prop(Type, p_array_const_val, "array_const_val")
		class_add_prop(Type, p_default_fmt, "default_fmt")
		class_add_prop(Type, p_mask, "mask")

	ArrayType = class_new("ArrayType", AST)
		class_add_prop(ArrayType, p_type, "type")
		class_add_prop(ArrayType, p_count, "count")

	UInt8Max	=  255
	UInt16Max	=  65535
	UInt32Max	=  4294967295
	Int8Min		= -128
	Int8Max		=  127
	Int16Min	= -32768
	Int16Max	=  32767
	Int32Min	= -2147483648
	Int32Max	=  2147483648
	CharMin		=  Int8Min
	CharMax		=  Int8Max

	UInt8	= type_new("u8", 1, 0, "BHND_NVRAM_TYPE_UINT8",
	   "BHND_NVRAM_TYPE_UINT8_ARRAY", FmtHex, UInt8Max, 0, 16)

	UInt16	= type_new("u16", 2, 0, "BHND_NVRAM_TYPE_UINT16",
	   "BHND_NVRAM_TYPE_UINT16_ARRAY", FmtHex, UInt16Max, 1, 17)

	UInt32	= type_new("u32", 4, 0, "BHND_NVRAM_TYPE_UINT32",
	   "BHND_NVRAM_TYPE_UINT32_ARRAY", FmtHex, UInt32Max, 2, 18)

	Int8	= type_new("i8", 1, 1, "BHND_NVRAM_TYPE_INT8",
	   "BHND_NVRAM_TYPE_INT8_ARRAY", FmtDec, UInt8Max, 4, 20)

	Int16	= type_new("i16", 2, 1, "BHND_NVRAM_TYPE_INT16",
	   "BHND_NVRAM_TYPE_INT16_ARRAY", FmtDec, UInt16Max, 5, 21)

	Int32	= type_new("i32", 4, 1, "BHND_NVRAM_TYPE_INT32",
	   "BHND_NVRAM_TYPE_INT32_ARRAY", FmtDec, UInt32Max, 6, 22)

	Char	= type_new("char", 1, 1, "BHND_NVRAM_TYPE_CHAR",
	   "BHND_NVRAM_TYPE_CHAR_ARRAY", FmtChar, UInt8Max, 8, 24)

	BaseTypes = map_new()
		map_set(BaseTypes, get(UInt8,	p_name), UInt8)
		map_set(BaseTypes, get(UInt16,	p_name), UInt16)
		map_set(BaseTypes, get(UInt32,	p_name), UInt32)
		map_set(BaseTypes, get(Int8,	p_name), Int8)
		map_set(BaseTypes, get(Int16,	p_name), Int16)
		map_set(BaseTypes, get(Int32,	p_name), Int32)
		map_set(BaseTypes, get(Char,	p_name), Char)

	BaseTypesArray = map_to_array(BaseTypes)
	BaseTypesCount = array_size(BaseTypesArray)

	# Variable Flags
	VFlag = class_new("VFlag")
		class_add_prop(VFlag, p_name, "name")
		class_add_prop(VFlag, p_const, "const")

	VFlagPrivate	= vflag_new("private", "BHND_NVRAM_VF_MFGINT")
	VFlagIgnoreAll1	= vflag_new("ignall1", "BHND_NVRAM_VF_IGNALL1")

	# Variable Access Type Constants
	VAccess = class_new("VAccess")
	VAccessPublic	= obj_new(VAccess)	# Public
	VAccessPrivate	= obj_new(VAccess)	# MFG Private
	VAccessInternal	= obj_new(VAccess)	# Implementation-Internal

	#
	# AST node classes
	#
	AST = class_new("AST")
		class_add_prop(AST, p_line, "line")

	SymbolContext = class_new("SymbolContext", AST)
		class_add_prop(SymbolContext, p_vars, "vars")

	# NVRAM root parser context
	NVRAM = class_new("NVRAM", SymbolContext)
		class_add_prop(NVRAM, p_var_groups, "var_groups")
		class_add_prop(NVRAM, p_srom_layouts, "srom_layouts")
		class_add_prop(NVRAM, p_srom_table, "srom_table")

	# Variable Group
	VarGroup = class_new("VarGroup", SymbolContext)
		class_add_prop(VarGroup, p_name, "name")

	# Revision Range
	RevRange = class_new("RevRange", AST)
		class_add_prop(RevRange, p_start, "start")
		class_add_prop(RevRange, p_end, "end")

	# String Constant
	StringConstant = class_new("StringConstant", AST)
		class_add_prop(StringConstant, p_value, "value")		# string
		class_add_prop(StringConstant, p_continued, "continued")	# bool

	# Variable Declaration
	Var = class_new("Var", AST)
		class_add_prop(Var, p_access, "access")		# VAccess
		class_add_prop(Var, p_name, "name")		# string
		class_add_prop(Var, p_desc, "desc")		# StringConstant
		class_add_prop(Var, p_help, "help")		# StringConstant
		class_add_prop(Var, p_type, "type")		# AbstractType
		class_add_prop(Var, p_fmt, "fmt")		# Fmt
		class_add_prop(Var, p_ignall1, "ignall1")	# bool
		# ID is assigned once all variables are sorted
		class_add_prop(Var, p_vid, "vid")		# int

	# Common interface inherited by parser contexts that support
	# registration of SROM variable entries
	SromContext = class_new("SromContext", AST)
		class_add_prop(SromContext, p_revisions, "revisions")

	# SROM Layout Node
	SromLayout = class_new("SromLayout", SromContext)
		class_add_prop(SromLayout, p_entries, "entries")	# Array<SromEntry>
		class_add_prop(SromLayout, p_revmap, "revmap")		# Map<(string,int), SromEntry>
		class_add_prop(SromLayout, p_output_var_counts,		# Map<int, int> (rev->count)
		    "output_var_counts")

	# SROM Layout Filter Node
	# Represents a filter over a parent SromLayout's revisions 
	SromLayoutFilter = class_new("SromLayoutFilter", SromContext)
		class_add_prop(SromLayoutFilter, p_parent, "parent")

	# SROM variable entry
	SromEntry = class_new("SromEntry", AST)
		class_add_prop(SromEntry, p_var, "var")
		class_add_prop(SromEntry, p_revisions, "revisions")
		class_add_prop(SromEntry, p_base_offset, "base_offset")
		class_add_prop(SromEntry, p_type, "type")
		class_add_prop(SromEntry, p_offsets, "offsets")

	# SROM variable offset
	SromOffset = class_new("SromOffset", AST)
		class_add_prop(SromOffset, p_segments, "segments")

	# SROM variable offset segment
	SromSegment = class_new("SromSegment", AST)
		class_add_prop(SromSegment, p_offset, "offset")
		class_add_prop(SromSegment, p_type, "type")
		class_add_prop(SromSegment, p_mask, "mask")
		class_add_prop(SromSegment, p_shift, "shift")
		class_add_prop(SromSegment, p_value, "value")

	# Create the parse state stack
	_g_parse_stack_depth = 0
	_g_parse_stack[0] = null

	# Push the root parse state
	parser_state_push(nvram_new(), 0)
}

function at_exit(_block_start, _state, _output_vars, _noutput_vars, _name, _var,
    _i)
{
	# Skip completion handling if exiting from an error
	if (_EARLY_EXIT)
		exit 1

	# Check for complete block closure
	if (!in_parser_context(NVRAM)) {
		_state = parser_state_get()
		_block_start = get(_state, p_line)
		errorx("missing '}' for block opened on line " _block_start "")
	}

	# Apply lexicographical sorting to our variable names. To support more
	# effecient table searching, we guarantee a stable sort order (using C
	# collation).
	#
	# This also has a side-effect of generating a unique monotonic ID
	# for all variables, which we will emit as a #define and can use as a
	# direct index into the C variable table
	_output_vars = array_new()
	for (_name in _g_var_names) {
		_var = _g_var_names[_name]

		# Don't include internal variables in the output
		if (var_is_internal(_var))
			continue

		array_append(_output_vars, _var)
	}

	# Sort by variable name
	array_sort(_output_vars, prop_to_path(p_name))

	# Set all variable ID properties to their newly assigned ID value
	_noutput_vars = array_size(_output_vars)
	for (_i = 0; _i < _noutput_vars; _i++) {
		_var = array_get(_output_vars, _i)
		set(_var, p_vid, _i)
	}

	# Truncate output file and write common header
	printf("") > OUTPUT_FILE
	emit("/*\n")
	emit(" * THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.\n")
	emit(" *\n")
	emit(" * generated from nvram map: " FILENAME "\n")
	emit(" */\n")
	emit("\n")

	# Emit all variable definitions
	if (OUT_T == OUT_T_DATA) {
		write_data(_output_vars)
	} else if (OUT_T == OUT_T_HEADER) {
		write_header(_output_vars)
	}
	if (VERBOSE == 1) {
	        printf("%u variable records written to %s\n", array_size(_output_vars),
		       OUTPUT_FILE) >> "/dev/stderr"
	}
}

# Write the public header (output type HEADER)
function write_header(output_vars, _noutput_vars, _var,
    _tab_align, _macro, _macros, _num_macros, _i)
{
	# Produce our array of #defines
	_num_macros = 0
	_noutput_vars = array_size(output_vars)
	for (_i = 0; _i < _noutput_vars; _i++) {
		_var = array_get(output_vars, _i)

		# Variable name
		_macro = var_get_macro(_var, MTypeVarName, \
		    "\"" get(_var, p_name) "\"")
		_macros[_num_macros++] = _macro

		# Variable array length
		if (var_has_array_type(_var)) {			
			_macro = var_get_macro(_var, MTypeVarMaxLen,
			    var_get_array_len(_var))
			_macros[_num_macros++] = _macro
		}
	}

	# Calculate value tab alignment position for our macros
	_tab_align = macros_get_tab_alignment(_macros, _num_macros)

	# Write the macros
	for (_i = 0; _i < _num_macros; _i++)
		write_macro_define(_macros[_i], _tab_align)
}

# Write the private data header (output type DATA)
function write_data(output_vars, _noutput_vars, _var, _nvram, _layouts,
    _nlayouts, _layout, _revs, _rev, _rev_start, _rev_end, _base_type,
    _srom_table, _nsrom_table, _i, _j)
{
	_nvram = parser_state_get_context(NVRAM)
	_layouts = get(_nvram, p_srom_layouts)
	_nlayouts = array_size(_layouts)

	_noutput_vars = array_size(output_vars)

	# Write all our private NVAR_ID defines
	write_data_defines(output_vars)

	# Write all layout binding opcodes, and build an array
	# mapping SROM revision to corresponding SROM layout
	_srom_table = array_new()
	for (_i = 0; _i < _nlayouts; _i++) {
		_layout = array_get(_layouts, _i)

		# Write binding opcode table to our output file
		write_srom_bindings(_layout)

		# Add entries to _srom_table for all covered revisions
		_revs = get(_layout, p_revisions)
		_rev_start = get(_revs, p_start)
		_rev_end = get(_revs, p_end)

		for (_j = _rev_start; _j <= _rev_end; _j++)
			array_append(_srom_table, _j)
	}

	# Sort in ascending order, by SROM revision
	array_sort(_srom_table)
	_nsrom_table = array_size(_srom_table)

	# Write the variable definitions
	emit("/* Variable definitions */\n")
	emit("const struct bhnd_nvram_vardefn " \
	    "bhnd_nvram_vardefns[] = {\n")
	output_depth++
	for (_i = 0; _i < _noutput_vars; _i++) {
		write_data_nvram_vardefn(array_get(output_vars, _i))
	}
	output_depth--
	emit("};\n")
	emit("const size_t bhnd_nvram_num_vardefns = " _noutput_vars ";\n")

	# Write static asserts for raw type constant values that must be kept
	# synchronized with the code
	for (_i = 0; _i < BaseTypesCount; _i++) {
		_base_type = array_get(BaseTypesArray, _i)

		emit(sprintf("_Static_assert(%s == %u, \"%s\");\n",
		    type_get_const(_base_type), type_get_const_val(_base_type),
		    "type constant out of sync"))

		emit(sprintf("_Static_assert(%s == %u, \"%s\");\n",
		    get(_base_type, p_array_const),
		    get(_base_type, p_array_const_val),
		    "array type constant out of sync"))
	}

	# Write all top-level bhnd_sprom_layout entries
	emit("/* SPROM layouts */\n")
	emit("const struct bhnd_sprom_layout bhnd_sprom_layouts[] = {\n")
	output_depth++
	for (_i = 0; _i < _nsrom_table; _i++) {
		_rev = array_get(_srom_table, _i)
		_layout = nvram_get_srom_layout(_nvram, _rev)
		write_data_srom_layout(_layout, _rev)
	}
	output_depth--
	emit("};\n")
	emit("const size_t bhnd_sprom_num_layouts = " _nsrom_table ";\n")
}

# Write a bhnd_nvram_vardef entry for the given variable
function write_data_nvram_vardefn(v, _desc, _help, _type, _fmt) {
	obj_assert_class(v, Var)

	_desc = get(v, p_desc)
	_help = get(v, p_help)
	_type = get(v, p_type)
	_fmt = var_get_fmt(v)

	emit("{\n")
	output_depth++
	emit(sprintf(".name = \"%s\",\n", get(v, p_name)))

	if (_desc != null)
		emit(sprintf(".desc = \"%s\",\n", get(_desc, p_value)))
	else
		emit(".desc = NULL,\n")

	if (_help != null)
		emit(sprintf(".help = \"%s\",\n", get(_help, p_value)))
	else
		emit(".help = NULL,\n")

	emit(".type = " type_get_const(_type) ",\n")
	emit(".nelem = " var_get_array_len(v) ",\n")
	emit(".fmt = &" get(_fmt, p_symbol) ",\n")
	emit(".flags = " gen_var_flags(v) ",\n")

	output_depth--
	emit("},\n")
}

# Write a top-level bhnd_sprom_layout entry for the given revision
# and layout definition
function write_data_srom_layout(layout, revision, _flags, _size,
    _sromcrc, _crc_seg, _crc_off,
    _sromsig, _sig_seg, _sig_offset, _sig_value,
    _sromrev, _rev_seg, _rev_off,
    _num_vars)
{
	_flags = array_new()

	# Calculate the size; it always follows the internal CRC variable
	_sromcrc = srom_layout_find_entry(layout, "<sromcrc>", revision)
	if (_sromcrc == null) {
		errorx("missing '<sromcrc>' entry for '"revision"' layout, " \
		    "cannot compute total size")
	} else {
		_crc_seg = srom_entry_get_single_segment(_sromcrc)
		_crc_off = get(_crc_seg, p_offset)
		_size = _crc_off
		_size += get(get(_crc_seg, p_type), p_width)
	}

	# Fetch signature definition
	_sromsig = srom_layout_find_entry(layout, "<sromsig>", revision)
	if (_sromsig == null) {
		array_append(_flags, "SPROM_LAYOUT_MAGIC_NONE")
	} else {
		_sig_seg = srom_entry_get_single_segment(_sromsig)

		_sig_offset = get(_sig_seg, p_offset)
		_sig_value = get(_sig_seg, p_value)
		if (_sig_value == "")
			errorc(get(_sromsig, p_line), "missing signature value")
	}

	# Fetch sromrev definition
	_sromrev = srom_layout_find_entry(layout, "sromrev", revision)
	if (_sromrev == null) {
		errorx("missing 'sromrev' entry for '"revision"' layout, " \
		    "cannot determine offset")
	} else {
		# Must be a u8 value
		if (!type_equal(get(_sromrev, p_type), UInt8)) {
			errorx("'sromrev' entry has non-u8 type '" \
			    type_to_string(get(_sromrev, p_type)))
		}

		_rev_seg = srom_entry_get_single_segment(_sromrev)
		_rev_off = get(_rev_seg, p_offset)
	}

	# Write layout entry
	emit("{\n")
	output_depth++
	emit(".size = "_size",\n")
	emit(".rev = "revision",\n")

	if (array_size(_flags) > 0) {
		emit(".flags = " array_join(_flags, "|") ",\n")
	} else {
		emit(".flags = 0,\n")
	}

	emit(".srev_offset = " _rev_off ",\n")

	if (_sromsig != null) {
		emit(".magic_offset = " _sig_offset ",\n")
		emit(".magic_value = " _sig_value ",\n")
	} else {
		emit(".magic_offset = 0,\n")
		emit(".magic_value = 0,\n")
	}

	emit(".crc_offset = " _crc_off ",\n")

	emit(".bindings = " srom_layout_get_variable_name(layout) ",\n")
	emit(".bindings_size = nitems(" \
	    srom_layout_get_variable_name(layout) "),\n")

	emit(".num_vars = " srom_layout_num_output_vars(layout, revision) ",\n")

	obj_delete(_flags)

	output_depth--
	emit("},\n");
}

# Create a new opstream encoding state instance for the given layout
function srom_ops_new(layout, _obj) {
	obj_assert_class(layout, SromLayout)

	_obj = obj_new(SromOpStream)
	set(_obj, p_layout, layout)
	set(_obj, p_revisions, get(layout, p_revisions))
	set(_obj, p_vid, 0)
	set(_obj, p_offset, 0)
	set(_obj, p_type, null)
	set(_obj, p_mask, null)
	set(_obj, p_shift, null)

	return (_obj)
}

# Return the current type width, or throw an error if no type is currently
# specified.
function srom_ops_get_type_width(opstream, _type)
{
	obj_assert_class(opstream, SromOpStream)

	_type = get(opstream, p_type)
	if (_type == null)
		errorx("no type value set")

	return (get(type_get_base(_type), p_width))
}

# Write a string to the SROM opcode stream, either buffering the write,
# or emitting it directly.
function srom_ops_emit(opstream, string, _pending_bind, _buffer) {
	obj_assert_class(opstream, SromOpStream)

	# Buffered?
	if ((_pending_bind = get(opstream, p_pending_bind)) != null) {
		_buffer = get(_pending_bind, p_buffer)
		array_append(_buffer, string)
		return
	}

	# Emit directly
	emit(string)
}

# Emit a SROM opcode followed by up to four optional bytes
function srom_ops_emit_opcode(opstream, opcode, arg0, arg1, arg2, arg3) {
	obj_assert_class(opstream, SromOpStream)

	srom_ops_emit(opstream, opcode",\n")
	if (arg0 != "") srom_ops_emit(opstream, arg0",\n")
	if (arg1 != "") srom_ops_emit(opstream, arg1",\n")
	if (arg2 != "") srom_ops_emit(opstream, arg2",\n")
	if (arg3 != "") srom_ops_emit(opstream, arg3",\n")
}

# Emit a SROM opcode and associated integer value, choosing the best
# SROM_OP_DATA variant for encoding the value.
#
# opc:		The standard opcode for non-IMM encoded data, or null if none
# opc_imm:	The IMM opcode, or null if none
# value:	The value to encode
# svalue:	Symbolic representation of value to include in output, or null
function srom_ops_emit_int_opcode(opstream, opc, opc_imm, value, svalue,
    _width, _offset, _delta)
{
	obj_assert_class(opstream, SromOpStream)

	# Fetch current type width
	_width = srom_ops_get_type_width(opstream)

	# Special cases:
	if (opc_imm == SPROM_OPCODE_SHIFT_IMM) {
		# SHIFT_IMM -- the imm value must be positive and divisible by
		# two (shift/2) to use the IMM form.
		if (value >= 0 && value % 2 == 0) {
			value = (value/2)
			opc = null
		} else {
			opc_imm = null
		}
	} else if (opc_imm == SPROM_OPCODE_OFFSET_REL_IMM) {
		# OFFSET_REL_IMM -- the imm value must be positive, divisible
		# by the type width, and relative to the last offset to use
		# the IMM form.

		# Assert that callers correctly flushed any pending bind before
		# attempting to set a relative offset
		if (get(opstream, p_pending_bind) != null)
			errorx("can't set relative offset with a pending bind")

		# Fetch current offset, calculate relative value and determine
		# whether we can issue an IMM opcode
		_offset = get(opstream, p_offset)
		_delta = value - _offset
		if (_delta >= 0 &&
		    _delta % _width == 0 &&
		    (_delta/_width) <= SPROM_OP_IMM_MAX)
		{
			srom_ops_emit(opstream,
			    sprintf("/* %#x + %#x -> %#x */\n", _offset,
			    _delta, value))
			value = (_delta / _width)
			opc = null
		} else {
			opc_imm = null
		}
	}

	# If no symbolic representation provided, write the raw value
	if (svalue == null)
		svalue = value

	# Try to encode as IMM value?
	if (opc_imm != null && value >= 0 && value <= SPROM_OP_IMM_MAX) {
		srom_ops_emit_opcode(opstream, "("opc_imm"|"svalue")")
		return
	}

	# Can't encode as immediate; do we have a non-immediate form?
	if (opc == null)
		errorx("can't encode '" value "' as immediate, and no " \
		    "non-immediate form was provided")

	# Determine and emit minimal encoding
	# We let the C compiler perform the bit operations, rather than
	# trying to wrestle awk's floating point arithmetic
	if (value < 0) {
		# Only Int8 is used
		 if (value < Int8Min)
			 errorx("cannot int8 encode '" value "'")

		srom_ops_emit_opcode(opstream,
		    "("opc"|"SPROM_OP_DATA_I8")", svalue)

	} else if (value <= UInt8Max) {

		srom_ops_emit_opcode(opstream,
		    "("opc"|"SPROM_OP_DATA_U8")", svalue)

	} else if (value % _width == 0 && (value / _width) <= UInt8Max) {

		srom_ops_emit_opcode(opstream,
		    "("opc"|"SPROM_OP_DATA_U8_SCALED")", svalue / _width)

	} else if (value <= UInt16Max) {

		srom_ops_emit_opcode(opstream,
		    "("opc"|"SPROM_OP_DATA_U16")", 
		    "("svalue" & 0xFF)",
		    "("svalue" >> 8)")

	} else if (value <= UInt32Max) {

		srom_ops_emit_opcode(opstream,
		    "("opc"|"SPROM_OP_DATA_U32")", 
		    "("svalue" & 0xFF)",
		    "(("svalue" >> 8) & 0xFF)",
		    "(("svalue" >> 16) & 0xFF)",
		    "(("svalue" >> 24) & 0xFF)")

	} else {
		errorx("can't encode '" value "' (too large)")
	}
}

# Emit initial OPCODE_VAR opcode and update opstream state
function srom_ops_reset_var(opstream, var, _vid_prev, _vid, _vid_name,
    _type, _base_type)
{
	obj_assert_class(opstream, SromOpStream)
	obj_assert_class(var, Var)

	# Flush any pending bind for the previous variable
	srom_ops_flush_bind(opstream, 1)

	# Fetch current state
	_vid_prev = get(opstream, p_vid)

	_vid = get(var, p_vid)
	_vid_name = var_get_macro_name(var, MTypeVarID)

	# Update state
	_type = get(var, p_type)
	set(opstream, p_vid, _vid)
	set(opstream, p_type, type_get_base(_type))
	set(opstream, p_nelem, var_get_array_len(var))
	set(opstream, p_mask, type_get_default_mask(_type))
	set(opstream, p_shift, 0)
	set(opstream, p_bind_total, 0)

	# Always provide a human readable comment
	srom_ops_emit(opstream, sprintf("/* %s (%#x) */\n", get(var, p_name),
	    get(opstream, p_offset)))

	# Prefer a single VAR_IMM byte
	if (_vid_prev == 0 || _vid <= SPROM_OP_IMM_MAX) {
		srom_ops_emit_int_opcode(opstream,
		    null, SPROM_OPCODE_VAR_IMM,
		    _vid, _vid_name)
		return
	}

	# Try encoding as a single VAR_REL_IMM byte
	if (_vid_prev <= _vid && (_vid - _vid_prev) <= SPROM_OP_IMM_MAX) {
		srom_ops_emit_int_opcode(opstream,
		    null, SPROM_OPCODE_VAR_REL_IMM,
		    _vid - _vid_prev, null)
		return
	}

	# Fall back on a multibyte encoding
	srom_ops_emit_int_opcode(opstream, SPROM_OPCODE_VAR, null, _vid,
	    _vid_name)
}

# Emit OPCODE_REV/OPCODE_REV_RANGE (if necessary) for a new revision range
function srom_ops_emit_revisions(opstream, revisions, _prev_revs,
    _start, _end)
{
	obj_assert_class(opstream, SromOpStream)
	_prev_revs = get(opstream, p_revisions)

	if (revrange_equal(_prev_revs, revisions))
		return;

	# Update stream state
	set(opstream, p_revisions, revisions)

	_start = get(revisions, p_start)
	_end = get(revisions, p_end)

	# Sanity-check range values
	if (_start < 0 || _end < 0)
		errorx("invalid range: " revrange_to_string(revisions))

	# If range covers a single revision, and can be encoded within
	# SROM_OP_IMM_MAX, we can use the single byte encoding
	if (_start == _end && _start <= SPROM_OP_IMM_MAX) {
		srom_ops_emit_int_opcode(opstream,
		    null, SPROM_OPCODE_REV_IMM, _start)
		return
	}

	# Otherwise, we need to use the two byte range encoding
	if (_start > SPROM_OP_REV_RANGE_MAX || _end > SPROM_OP_REV_RANGE_MAX) {
		errorx(sprintf("cannot encode range values %s (>= %u)",
		    revrange_to_string(revisions), SPROM_OP_REV_RANGE_MAX))
	}

	srom_ops_emit_opcode(opstream,
	    SPROM_OPCODE_REV_RANGE,
	    sprintf("(%u << %s) | (%u << %s)",
		_start, SPROM_OP_REV_START_SHIFT,
		_end, SPROM_OP_REV_END_SHIFT))
}

# Emit OPCODE_OFFSET (if necessary) for a new offset
function srom_ops_emit_offset(opstream, offset, _prev_offset, _rel_offset,
    _bind)
{
	obj_assert_class(opstream, SromOpStream)

	# Flush any pending bind before adjusting the offset
	srom_ops_flush_bind(opstream, 0)

	# Fetch current offset
	_prev_offset = get(opstream, p_offset)
	if (_prev_offset == offset)
		return

	# Encode (possibly a relative, 1-byte form) of the offset opcode
	srom_ops_emit_int_opcode(opstream, SPROM_OPCODE_OFFSET,
	    SPROM_OPCODE_OFFSET_REL_IMM, offset, null)

	# Update state
	set(opstream, p_offset, offset)
}

# Emit OPCODE_TYPE (if necessary) for a new type value; this also
# resets the mask to the type default.
function srom_ops_emit_type(opstream, type, _base_type, _prev_type, _prev_mask,
    _default_mask)
{
	obj_assert_class(opstream, SromOpStream)
	if (!obj_is_instanceof(type, ArrayType))
		obj_assert_class(type, Type)

	_default_mask = type_get_default_mask(type)
	_base_type = type_get_base(type)

	# If state already matches the requested type, nothing to be
	# done
	_prev_type = get(opstream, p_type)
	_prev_mask = get(opstream, p_mask)
	if (type_equal(_prev_type, _base_type) && _prev_mask == _default_mask)
		return

	# Update state
	set(opstream, p_type, _base_type)
	set(opstream, p_mask, _default_mask)

	# Emit opcode.
	if (type_get_const_val(_base_type) <= SPROM_OP_IMM_MAX) {
		# Single byte IMM encoding
		srom_ops_emit_opcode(opstream,
		    SPROM_OPCODE_TYPE_IMM "|" type_get_const(_base_type))
	} else {
		# Two byte encoding
		srom_ops_emit_opcode(opstream, SPROM_OPCODE_TYPE,
		    type_get_const(_base_type))
	}
}

# Emit OPCODE_MASK (if necessary) for a new mask value
function srom_ops_emit_mask(opstream, mask, _prev_mask) {
	obj_assert_class(opstream, SromOpStream)
	_prev_mask = get(opstream, p_mask)

	if (_prev_mask == mask)
		return

	set(opstream, p_mask, mask)
	srom_ops_emit_int_opcode(opstream,
	    SPROM_OPCODE_MASK, SPROM_OPCODE_MASK_IMM,
	    mask, sprintf("0x%x", mask))
}

# Emit OPCODE_SHIFT (if necessary) for a new shift value
function srom_ops_emit_shift(opstream, shift, _prev_shift) {
	obj_assert_class(opstream, SromOpStream)
	_prev_shift = get(opstream, p_shift)

	if (_prev_shift == shift)
		return

	set(opstream, p_shift, shift)
	srom_ops_emit_int_opcode(opstream,
	    SPROM_OPCODE_SHIFT, SPROM_OPCODE_SHIFT_IMM,
	    shift, null)
}

# Return true if a valid BIND/BINDN encoding exists for the given SKIP_IN
# value, false if the skip values exceed the limits of the bind opcode
# family.
function srom_ops_can_encode_skip_in(skip_in) {
	return (skip_in >= SPROM_OP_BIND_SKIP_IN_MIN &&
	    skip_in <= SPROM_OP_BIND_SKIP_IN_MAX)
}

# Return true if a valid BIND/BINDN encoding exists for the given SKIP_OUT
# value, false if the skip values exceed the limits of the bind opcode
# family.
function srom_ops_can_encode_skip_out(skip_out) {
	return (skip_in >= SPROM_OP_BIND_SKIP_IN_MIN &&
	    skip_in <= SPROM_OP_BIND_SKIP_IN_MAX)
}

# Return true if a valid BIND/BINDN encoding exists for the given skip
# values, false if the skip values exceed the limits of the bind opcode
# family.
function srom_ops_can_encode_skip(skip_in, skip_out) {
	return (srom_ops_can_encode_skip_in(skip_in) &&
	    srom_ops_can_encode_skip_out(skip_out))
}

# Create a new SromOpBind instance for the given segment
function srom_opbind_new(segment, skip_in, skip_out, _obj, _type, _width,
    _offset)
{
	obj_assert_class(segment, SromSegment)

	# Verify that an encoding exists for the skip values
	if (!srom_ops_can_encode_skip_in(skip_in)) {
		errorx(sprintf("cannot encode SKIP_IN=%d; maximum supported " \
		    "range %d-%d", skip_in,
		    SPROM_OP_BIND_SKIP_IN_MIN, SPROM_OP_BIND_SKIP_IN_MAX))
	}

	if (!srom_ops_can_encode_skip_out(skip_out)) {
		errorx(sprintf("cannot encode SKIP_OUT=%d; maximum supported " \
		    "range %d-%d", skip_out,
		    SPROM_OP_BIND_SKIP_OUT_MIN, SPROM_OP_BIND_SKIP_OUT_MAX))
	}

	# Fetch basic segment info
	_offset = get(segment, p_offset)
	_type = srom_segment_get_base_type(segment)
	_width = get(_type, p_width)

	# Construct new instance
	_obj = obj_new(SromOpBind)

	set(_obj, p_segment, segment)
	set(_obj, p_count, 1)
	set(_obj, p_offset, _offset)
	set(_obj, p_width, _width)
	set(_obj, p_skip_in, skip_in)
	set(_obj, p_skip_out, skip_out)
	set(_obj, p_buffer, array_new())

	return (_obj)
}

# Try to coalesce a BIND for the given segment with an existing bind request,
# returning true on success, or false if the two segments cannot be coalesced
# into the existing request
function srom_opbind_append(bind, segment, skip_out, _bind_seg, _bind_off,
    _width, _count, _skip_in, _seg_offset, _delta)
{
	obj_assert_class(bind, SromOpBind)
	obj_assert_class(segment, SromSegment)

	# Are the segments compatible?
	_bind_seg = get(bind, p_segment)
	if (!srom_segment_attributes_equal(_bind_seg, segment))
		return (0)

	# Are the output skip values compatible?
	if (get(bind, p_skip_out) != skip_out)
		return (0)

	# Find bind offset/count/width/skip
	_bind_off = get(bind, p_offset)
	_count = get(bind, p_count)
	_skip_in = get(bind, p_skip_in)
	_width = get(bind, p_width)

	# Fetch new segment's offset
	_seg_offset = get(segment, p_offset)

	# If there's only one segment in the bind op, we ned to compute the
	# skip value to be used for all later segments (including the
	# segment we're attempting to append)
	#
	# If there's already multiple segments, we just need to verify that
	# the bind_offset + (count * width * skip_in) produces the new
	# segment's offset
	if (_count == 1) {
		# Determine the delta between the two segment offsets. This
		# must be a multiple of the type width to be encoded
		# as a BINDN entry
		_delta = _seg_offset - _bind_off
		if ((_delta % _width) != 0)
			return (0)

		# The skip byte count is calculated as (type width * skip)
		_skip_in = _delta / _width

		# Is the skip encodable?
		if (!srom_ops_can_encode_skip_in(_skip_in))
			return (0)

		# Save required skip
		set(bind, p_skip_in, _skip_in)
	} else if (_count > 1) {
		# Get the final offset of the binding if we were to add
		# one additional segment
		_bind_off = _bind_off + (_width * _skip_in * (_count + 1))

		# If it doesn't match our segment's offset, we can't
		# append this segment
		if (_bind_off != _seg_offset)
			return (0)
	}

	# Success! Increment the bind count in the existing bind
	set(bind, p_count, _count + 1)
	return (1)
}

# Return true if the given binding operation can be omitted from the output
# if it would be immediately followed by a VAR, VAR_REL_IMM, or EOF opcode.
#
# The bind operatin must be configured with default count, skip_in, and 
# skip_out values of 1, and must contain no buffered post-BIND opcodes 
function srom_opbind_is_implicit_encodable(bind) {
	obj_assert_class(bind, SromOpBind)

	if (get(bind, p_count) != 1)
		return (0)

	if (get(bind, p_skip_in) != 1)
		return (0)

	if (get(bind, p_skip_out) != 1)
		return (0)

	if (array_size(get(bind, p_buffer)) != 0)
		return (0)

	return (1)
}


# Encode all segment settings for a single offset segment, followed by a bind
# request.
#
# opstream:	Opcode stream
# segment:	Segment to be written
# continued:	If this segment's value should be OR'd with the value of a
#		following segment
function srom_ops_emit_segment(opstream, segment, continued, _value,
    _bind, _skip_in, _skip_out)
{
	obj_assert_class(opstream, SromOpStream)
	obj_assert_class(segment, SromSegment)

	# Determine basic bind parameters
	_count = 1
	_skip_in = 1
	_skip_out = continued ? 0 : 1

	# Try to coalesce with a pending binding
	if ((_bind = get(opstream, p_pending_bind)) != null) {
		if (srom_opbind_append(_bind, segment, _skip_out))
			return
	}

	# Otherwise, flush any pending bind and enqueue our own
	srom_ops_flush_bind(opstream, 0)
	if (get(opstream, p_pending_bind))
		errorx("bind not flushed!")

	# Encode type
	_value = get(segment, p_type)
	srom_ops_emit_type(opstream, _value)

	# Encode offset
	_value = get(segment, p_offset)
	srom_ops_emit_offset(opstream, _value)

	# Encode mask
	_value = get(segment, p_mask)
	srom_ops_emit_mask(opstream, _value)

	# Encode shift
	_value = get(segment, p_shift)
	srom_ops_emit_shift(opstream, _value)

	# Enqueue binding with opstream
	_bind = srom_opbind_new(segment, _skip_in, _skip_out)
	set(opstream, p_pending_bind, _bind)
}

# (private) Adjust the stream's input offset by applying the given bind
# operation's skip_in * width * count.
function _srom_ops_apply_bind_offset(opstream, bind, _count, _offset, _width,
    _skip_in, _opstream_offset)
{
	obj_assert_class(opstream, SromOpStream)
	obj_assert_class(bind, SromOpBind)

	_opstream_offset = get(opstream, p_offset)
	_offset = get(bind, p_offset)
	if (_opstream_offset != _offset)
		errorx("stream/bind offset state mismatch")

	_count = get(bind, p_count)
	_width = get(bind, p_width)
	_skip_in = get(bind, p_skip_in)

	set(opstream, p_offset,
	    _opstream_offset + ((_width * _skip_in) * _count))
}

# (private) Write a bind instance and all buffered opcodes
function _srom_ops_emit_bind(opstream, bind, _count, _skip_in, _skip_out,
    _off_start, _width, _si_signbit, _written, _nbuffer, _buffer)
{
	obj_assert_class(opstream, SromOpStream)
	obj_assert_class(bind, SromOpBind)

	# Assert that any pending bind state has already been cleared
	if (get(opstream, p_pending_bind) != null)
		errorx("cannot flush bind with an existing pending_bind active")

	# Fetch (and assert valid) our skip values
	_skip_in = get(bind, p_skip_in)
	_skip_out = get(bind, p_skip_out)

	if (!srom_ops_can_encode_skip(_skip_in, _skip_out))
		errorx("invalid skip values in buffered bind")

	# Determine SKIP_IN sign bit
	_si_signbit = "0"
	if (_skip_in < 0)
		_si_signbit = SPROM_OP_BIND_SKIP_IN_SIGN

	# Emit BIND/BINDN opcodes until the full count is encoded
	_count = get(bind, p_count)
	while (_count > 0) {
		if (_count > 1 && _count <= SPROM_OP_IMM_MAX &&
		    _skip_in == 1 && _skip_out == 1)
		{
			# The one-byte BINDN form requires encoding the count
			# as a IMM, and has an implicit in/out skip of 1.
			srom_ops_emit_opcode(opstream,
			    "("SPROM_OPCODE_DO_BINDN_IMM"|"_count")")
			_count -= _count

		} else if (_count > 1) {
			# The two byte BINDN form can encode skip values and a
			# larger U8 count
			_written = min(_count, UInt8Max)

			srom_ops_emit_opcode(opstream,
			    sprintf("(%s|%s|(%u<<%s)|(%u<<%s))",
				SPROM_OPCODE_DO_BINDN,
				_si_signbit,
				abs(_skip_in), SPROM_OP_BIND_SKIP_IN_SHIFT,
				_skip_out, SPROM_OP_BIND_SKIP_OUT_SHIFT),
			    _written)
			_count -= _written

		} else {
			# The 1-byte BIND form can encode the same SKIP values
			# as the 2-byte BINDN, with a implicit count of 1
			srom_ops_emit_opcode(opstream,
			    sprintf("(%s|%s|(%u<<%s)|(%u<<%s))",
				SPROM_OPCODE_DO_BIND,
				_si_signbit,
				abs(_skip_in), SPROM_OP_BIND_SKIP_IN_SHIFT,
				_skip_out, SPROM_OP_BIND_SKIP_OUT_SHIFT))
			_count--
		}
	}

	# Update the stream's input offset
	_srom_ops_apply_bind_offset(opstream, bind)

	# Write any buffered post-BIND opcodes
	_buffer = get(bind, p_buffer)
	_nbuffer = array_size(_buffer)
	for (_i = 0; _i < _nbuffer; _i++)
		srom_ops_emit(opstream, array_get(_buffer, _i))
}

# Flush any buffered binding
function srom_ops_flush_bind(opstream, allow_implicit, _bind, _bind_total)
{
	obj_assert_class(opstream, SromOpStream)

	# If no pending bind, nothing to flush
	if ((_bind = get(opstream, p_pending_bind)) == null)
		return

	# Check the per-variable bind count to determine whether
	# we can encode an implicit bind.
	#
	# If there have been any explicit bind statements, implicit binding
	# cannot be used.
	_bind_total = get(opstream, p_bind_total)
	if (allow_implicit && _bind_total > 0) {
		# Disable implicit encoding; explicit bind statements have
		# been issued for this variable previously.
		allow_implicit = 0
	}

	# Increment bind count
	set(opstream, p_bind_total, _bind_total + 1)

	# Clear the property value
	set(opstream, p_pending_bind, null)

	# If a pending bind operation can be encoded as an implicit bind,
	# emit a descriptive comment and update the stream state.
	#
	# Otherwise, emit the full set of bind opcode(s)
	_base_off = get(opstream, p_offset)
	if (allow_implicit && srom_opbind_is_implicit_encodable(_bind)) {
		# Update stream's input offset
		_srom_ops_apply_bind_offset(opstream, _bind)
	} else {
		_srom_ops_emit_bind(opstream, _bind)
	}

	# Provide bind information as a comment
	srom_ops_emit(opstream,
	    sprintf("/* bind (%s @ %#x -> %#x) */\n",
		type_to_string(get(opstream, p_type)),
		_base_off, get(opstream, p_offset)))

	# Clean up
	obj_delete(_bind)
}

# Write OPCODE_EOF after flushing any buffered writes
function srom_ops_emit_eof(opstream) {
	obj_assert_class(opstream, SromOpStream)

	# Flush any buffered writes
	srom_ops_flush_bind(opstream, 1)

	# Emit an explicit VAR_END opcode for the last entry
	srom_ops_emit_opcode(opstream, SPROM_OPCODE_VAR_END)

	# Emit EOF
	srom_ops_emit_opcode(opstream, SPROM_OPCODE_EOF)
}

# Write the SROM offset segment bindings to the opstream
function write_srom_offset_bindings(opstream, offsets,
    _noffsets, _offset, _segs, _nsegs, _segment, _cont,
    _i, _j)
{
	_noffsets = array_size(offsets)
	for (_i = 0; _i < _noffsets; _i++) {
		# Encode each segment in this offset 
		_offset = array_get(offsets, _i)
		_segs = get(_offset, p_segments)
		_nsegs = array_size(_segs)

		for (_j = 0; _j < _nsegs; _j++) {
			_segment = array_get(_segs, _j)
			_cont = 0
			
			# Should this value be OR'd with the next segment?
			if (_j+1 < _nsegs)
				_cont = 1 

			# Encode segment
			srom_ops_emit_segment(opstream, _segment, _cont)
		}
	}
}

# Write the SROM entry stream for a SROM entry to the output file
function write_srom_entry_bindings(entry, opstream, _var, _vid,
    _var_type, _entry_type, _offsets, _noffsets)
{
	_var = get(entry, p_var)
	_vid = get(_var, p_vid)

	# Encode revision switch. This resets variable state, so must
	# occur before any variable definitions to which it applies
	srom_ops_emit_revisions(opstream, get(entry, p_revisions))

	# Encode variable ID
	srom_ops_reset_var(opstream, _var, _vid)
	output_depth++

	# Write entry-specific array length (SROM layouts may define array
	# mappings with fewer elements than in the variable definition)
	if (srom_entry_has_array_type(entry)) {
		_var_type = get(_var, p_type)
		_entry_type = get(entry, p_type)

		# If the array length differs from the variable default,
		# write an OPCODE_EXT_NELEM entry
		if (type_get_nelem(_var_type) != type_get_nelem(_entry_type)) {
			srom_ops_emit_opcode(opstream, SPROM_OPCODE_NELEM,
			    srom_entry_get_array_len(entry))
		}
	}

	# Write offset segment bindings
	_offsets = get(entry, p_offsets)
	write_srom_offset_bindings(opstream, _offsets)
	output_depth--
}

# Write a SROM layout binding opcode table to the output file
function write_srom_bindings(layout, _varname, _var, _all_entries,
    _nall_entries, _entries, _nentries, _entry, _opstream, _i)
{
	_varname = srom_layout_get_variable_name(layout)
	_all_entries = get(layout, p_entries)
	_opstream = srom_ops_new(layout)

	#
	# Collect all entries to be included in the output, and then
	# sort by their variable's assigned ID (ascending).
	#
	# The variable IDs were previously assigned in lexigraphical sort
	# order; since the variable *offsets* tend to match this order, this
	# works out well for our compact encoding, allowing us to make use of
	# compact relative encoding of both variable IDs and variable offsets.
	#
	_entries = array_new()
	_nall_entries = array_size(_all_entries)
	for (_i = 0; _i < _nall_entries; _i++) {
		_entry = array_get(_all_entries, _i)
		_var = get(_entry, p_var)

		# Skip internal variables
		if (var_is_internal(_var))
			continue

		# Sanity check variable ID assignment
		if (get(_var, p_vid) == "")
			errorx("missing variable ID for " obj_to_string(_var))
	
		array_append(_entries, _entry)
	}

	# Sort entries by (variable ID, revision range), ascending
	array_sort(_entries, prop_path_create(p_var, p_vid),
	    prop_path_create(p_revisions, p_start),
	    prop_path_create(p_revisions, p_end))

	# Emit all entry binding opcodes
	emit("static const uint8_t " _varname "[] = {\n")
	output_depth++

	_nentries = array_size(_entries)
	for (_i = 0; _i < _nentries; _i++) {
		_entry = array_get(_entries, _i)
		write_srom_entry_bindings(_entry, _opstream)
	}

	# Flush and write EOF
	srom_ops_emit_eof(_opstream)

	output_depth--
	emit("};\n")

	obj_delete(_opstream)
	obj_delete(_entries)
}

# Write the BHND_NVAR_<NAME>_ID #defines to the output file
function write_data_defines(output_vars, _noutput_vars, _tab_align, _var,
    _macro, _macros, _num_macros, _i)
{
	# Produce our array of #defines
	_num_macros = 0
	_noutput_vars = array_size(output_vars)
	for (_i = 0; _i < _noutput_vars; _i++) {
		_var = array_get(output_vars, _i)

		# Variable ID
		_macro = var_get_macro(_var, MTypeVarID, get(_var, p_vid))
		_macros[_num_macros++] = _macro
	}

	# Calculate value tab alignment position for our macros
	_tab_align = macros_get_tab_alignment(_macros, _num_macros)

	# Write the #defines
	emit("/* ID constants provide an index into the variable array */\n")
	for (_i = 0; _i < _num_macros; _i++)
		write_macro_define(_macros[_i], _tab_align)
	emit("\n\n");
}

# Calculate the common tab alignment to be used with a set of prefix strings
# with the given maximum length
function tab_alignment(max_len, _tab_align) {
	_tab_align = max_len
	_tab_align += (TAB_WIDTH - (_tab_align % TAB_WIDTH)) % TAB_WIDTH
	_tab_align /= TAB_WIDTH

	return (_tab_align)
}

# Generate and return a tab string that can be appended to a string of
# `strlen` to pad the column out to `align_to`
#
# Note: If the string from which strlen was derived contains tabs, the result
# is undefined
function tab_str(strlen, align_to, _lead, _pad, _result, _i) {
	_lead = strlen
	_lead -= (_lead % TAB_WIDTH);
	_lead /= TAB_WIDTH;

	# Determine required padding to reach the desired alignment
	if (align_to >= _lead)
		_pad = align_to - _lead;
	else
		_pad = 1;

	for (_i = 0; _i < _pad; _i++)
		_result = _result "\t"

	return (_result)
}


# Write a MacroDefine constant, padding the constant out to `align_to`
function write_macro_define(macro, align_to, _tabstr, _i) {
	# Determine required padding to reach the desired alignment
	_tabstr = tab_str(length(get(macro, p_name)), align_to)

	emit("#define\t" get(macro, p_name) _tabstr get(macro, p_value) "\n")
}

# Calculate the tab alignment to be used with a given integer-indexed array
# of Macro instances.
function macros_get_tab_alignment(macros, macros_len, _macro, _max_len, _i) {
	_max_len = 0
	for (_i = 0; _i < macros_len; _i++) {
		_macro = macros[_i]
		_max_len = max(_max_len, length(get(_macro, p_name)))
	}

	return (tab_alignment(_max_len))
}

# Variable group block
$1 == "group" && in_parser_context(NVRAM) {
	parse_variable_group()
}

# Variable definition
(($1 ~ VACCESS_REGEX && $2 ~ TYPES_REGEX) || $1 ~ TYPES_REGEX) &&
    in_parser_context(SymbolContext) \
{
	parse_variable_defn()
}

# Variable "fmt" parameter
$1 == "fmt" && in_parser_context(Var) {
	parse_variable_param($1)
	next
}

# Variable "all1" parameter
$1 == "all1" && in_parser_context(Var) {
	parse_variable_param($1)
	next
}

# Variable desc/help parameters
($1 == "desc" || $1 == "help") && in_parser_context(Var) {
	parse_variable_param($1)
	next
}

# SROM layout block
$1 == "srom" && in_parser_context(NVRAM) {
	parse_srom_layout()
}


# SROM layout revision filter block
$1 == "srom" && in_parser_context(SromLayout) {
	parse_srom_layout_filter()
}

# SROM layout variable entry
$1 ~ "("OFF_REGEX"):$" && \
    (in_parser_context(SromLayout) || in_parser_context(SromLayoutFilter)) \
{
	parse_srom_variable_entry()
}


# SROM entry segment
$1 ~ "("REL_OFF_REGEX"|"OFF_REGEX")[:,|]?" && in_parser_context(SromEntry) {
	parse_srom_entry_segments()
}

# Skip comments and blank lines
/^[ \t]*#/ || /^$/ {
	next
}

# Close blocks
/}/ && !in_parser_context(NVRAM) {
	while (!in_parser_context(NVRAM) && $0 ~ "}") {
		parser_state_close_block();
	}
	next
}

# Report unbalanced '}'
/}/ && in_parser_context(NVRAM) {
	error("extra '}'")
}

# Invalid variable type
$1 && in_parser_context(SymbolContext) {
	error("unknown type '" $1 "'")
}

# Generic parse failure
{
	error("unrecognized statement")
}

# Create a class instance with the given name
function class_new(name, superclass, _class) {
	if (_class != null)
		errorx("class_get() must be called with one or two arguments")

	# Look for an existing class instance
	if (name in _g_class_names)
		errorx("redefining class: " name)

	# Create and register the class object
	_class = obj_new(superclass)
	_g_class_names[name] = _class
	_g_obj[_class,OBJ_IS_CLS] = 1
	_g_obj[_class,CLS_NAME] = name

	return (_class)
}

# Return the class instance with the given name
function class_get(name) {
	if (name in _g_class_names)
		return (_g_class_names[name])

	errorx("no such class " name)
}

# Return the name of cls
function class_get_name(cls) {
	if (cls == null) {
		warnx("class_get_name() called with null class")
		return "<null>"
	}

	if (!obj_is_class(cls))
		errorx(cls " is not a class object")

	return (_g_obj[cls,CLS_NAME])
}

# Return true if the given property property ID is defined on class
function class_has_prop_id(class, prop_id, _super) {
	if (_super != null)
		errorx("class_has_prop_id() must be called with two arguments")

	if (class == null)
		return (0)

	if (prop_id == null)
		return (0)

	# Check class<->prop cache
	if ((class, prop_id) in _g_class_prop_cache)
		return (1)

	# Otherwise, slow path
	if (!obj_is_class(class))
		errorx(class " is not a class object")

	if (_super != null)
		errorx("class_has_prop_id() must be called with two arguments")

	for (_super = class; _super != null; _super = obj_get_class(_super)) {
		if (!((_super,CLS_PROP,prop_id) in _g_obj))
			continue

		# Found; add to class<->prop cache
		_g_class_prop_cache[class,prop_id] = 1
		return (1)
	}

	return (0)
}

# Return true if the given property prop is defined on class
function class_has_property(class, prop) {
	if (!(PROP_ID in prop))
		return (0)

	return (class_has_prop_id(class, prop[PROP_ID]))
}

# Define a `prop` on `class` with the given `name` string
function class_add_prop(class, prop, name, _prop_id) {
	if (_prop_id != null)
		errorx("class_add_prop() must be called with three arguments")

	# Check for duplicate property definition
	if (class_has_property(class, prop))
		errorx("property " prop[PROP_NAME] " already defined on " \
		    class_get_name(class))

	# Init property IDs
	if (_g_prop_ids == null)
		_g_prop_ids = 1

	# Get (or create) new property entry
	if (name in _g_prop_names) {
		_prop_id = _g_prop_names[name]
	} else {
		_prop_id = _g_prop_ids++
		_g_prop_names[name] = _prop_id
		_g_props[_prop_id] = name

		prop[PROP_NAME]	= name
		prop[PROP_ID]	= _prop_id
	}

	# Add to class definition
	_g_obj[class,CLS_PROP,prop[PROP_ID]] = name
	return (name)
}

# Return the property ID for a given class-defined property
function class_get_prop_id(class, prop) {
	if (class == null)
		errorx("class_get_prop_id() on null class")

	if (!class_has_property(class, prop)) {
		errorx("requested undefined property '" prop[PROP_NAME] "on " \
		    class_get_name(class))
	}

	return (prop[PROP_ID])
}

# Return the property ID for a given class-defined property name
function class_get_named_prop_id(class, name, _prop_id) {
	if (class == null)
		errorx("class_get_prop_id() on null class")

	if (!(name in _g_prop_names))
		errorx("requested undefined property '" name "'")

	_prop_id = _g_prop_names[name]

	if (!class_has_prop_id(class, _prop_id)) {
		errorx("requested undefined property '" _g_props[_prop_id] \
		    "' on " class_get_name(class))
	}

	return (_prop_id)
}

# Create a new instance of the given class
function obj_new(class, _obj) {
	if (_obj != null)
		errorx("obj_new() must be called with one argument")

	if (_g_obj_ids == null)
		_g_obj_ids = 1

	# Assign ID and set superclass
	_obj = _g_obj_ids++
	_g_obj[_obj,OBJ_SUPER] = class

	return (_obj)
}

# obj_delete() support for Map instances
function _obj_delete_map(obj, _prefix, _key) {
	obj_assert_class(obj, Map)
	_prefix = "^" obj SUBSEP
	for (_key in _g_maps) {
		if (!match(_key, _prefix) && _key != obj)
			continue
		delete _g_maps[_key]
	}
}

# obj_delete() support for Array instances
function _obj_delete_array(obj, _size, _i) {
	obj_assert_class(obj, Array)
	_size = array_size(obj)

	for (_i = 0; _i < _size; _i++)
		delete _g_arrays[obj,OBJ_PROP,_i]
}

# Destroy all metadata associated with the given object
function obj_delete(obj, _prop_id, _prop_name, _prefix, _key, _size, _i) {
	if (obj_is_class(obj))
		errorx("cannot delete class objects")

	# Handle classes that use external global array storage
	# for effeciency
	if (obj_is_instanceof(obj, Map)) {
		_obj_delete_map(obj)
	} else if (obj_is_instanceof(obj, Array)) {
		_obj_delete_array(obj)
	}

	# Delete all object properties
	for (_prop_name in _g_prop_names) {
		if (!obj_has_prop_id(obj, _prop_id))
			continue

		_prop_id = _g_prop_names[_prop_name]
		delete _g_obj[obj,OBJ_PROP,_prop_id]
		delete _g_obj_nr[obj,OBJ_PROP,_prop_id]
	}

	# Delete instance state
	delete _g_obj[obj,OBJ_IS_CLS]
	delete _g_obj[obj,OBJ_SUPER]
}

# Print an object's unique ID, class, and properties to
# stdout
function obj_dump(obj, _pname, _prop_id, _prop_val) {
	print(class_get_name(obj_get_class(obj)) "<" obj ">:")

	# Dump all properties
	for (_pname in _g_prop_names) {
		_prop_id = _g_prop_names[_pname]

		if (!obj_has_prop_id(obj, _prop_id))
			continue

		_prop_val = prop_get(obj, _prop_id)
		printf("\t%s: %s\n", _pname, _prop_val)
	}
}

# Return true if obj is a class object
function obj_is_class(obj) {
	return (_g_obj[obj,OBJ_IS_CLS] == 1)
}

# Return the class of obj, if any.
function obj_get_class(obj) {
	if (obj == null)
		errorx("obj_get_class() on null object")
	return (_g_obj[obj,OBJ_SUPER])
}

# Return true if obj is an instance of the given class
function obj_is_instanceof(obj, class, _super) {
	if (_super != null)
		errorx("obj_is_instanceof() must be called with two arguments")

	if (!obj_is_class(class))
		errorx(class " is not a class object")

	if (obj == null) {
		errorx("obj_is_instanceof() called with null obj (class " \
		    class_get_name(class) ")")
	}

	for (_super = obj_get_class(obj); _super != null;
	     _super = obj_get_class(_super))
	{
		if (_super == class)
			return (1)
	}

	return (0)
}

# Default object shallow equality implementation. Returns true if the two
# objects share a common superclass and have identity equality across all defined
# properties.
function obj_trivially_equal(lhs, rhs, _class, _pname, _prop_id) {
	# Simple case
	if (lhs == rhs)
		return (1)

	# Must share a common superclass
	_class = obj_get_class(lhs)
	if (_class != obj_get_class(rhs))
		return (0)

	# Compare all properties
	_prop_count = 0
	for (_pname in _g_prop_names) {
		_prop_id = _g_prop_names[_pname]

		if (!class_has_prop_id(_class, _prop_id))
			continue

		if (prop_get(lhs, _prop_id) != prop_get(rhs, _prop_id))
			return (0)
	}

	# All properties are trivially equal
	return (1)
}


# Return a debug string representation of an object's unique ID, class, and
# properties
function obj_to_string(obj, _pname, _prop_id, _prop_val, _prop_count, _result) {
	_result = class_get_name(obj_get_class(obj)) "<" obj ">: { "

	# Fetch all properties
	_prop_count = 0
	for (_pname in _g_prop_names) {
		_prop_id = _g_prop_names[_pname]

		if (!obj_has_prop_id(obj, _prop_id))
			continue

		if (_prop_count >= 0)
			_result = _result ", "

		_result = _result sprintf("\t%s: %s\n", _pname, _prop_val)
		_prop_count++
	}

	return (_result " }")
}

# Assert that obj is an instance of the given class
function obj_assert_class(obj, class) {
	if (!obj_is_instanceof(obj, class)) {
		errorx(class_get_name(obj_get_class(obj)) "<" obj "> is not " \
		    "an instance of " class_get_name(class))
	}
}

# Return true if the given property prop is defined by the object's superclass
function obj_has_property(obj, prop, _class) {
	if (obj == null)
		errorx("obj_has_property() on null object")

	_class = obj_get_class(obj)
	return (class_has_property(_class, prop))
}

# Return true if the given property ID is defined by the object's superclass
function obj_has_prop_id(obj, prop_id, _class) {
	if (obj == null)
		errorx("obj_has_prop_id() on null object")

	_class = obj_get_class(obj)
	return (class_has_prop_id(_class, prop_id))
}

# Return the line (NR) at which a given property ID was set on the object
# Will throw an error if the property has not been set on obj
function obj_get_prop_id_nr(obj, prop_id) {
	if (obj == null)
		errorx("obj_get_prop_id_nr() on null object")

	if (!obj_has_prop_id(obj, prop_id)) {
		errorx("requested undefined property '" _g_props[prop_id] \
		    "' (" prop_id ") on " obj_to_string(obj))
	}

	# Fetch NR
	if ((obj,OBJ_PROP,prop_id) in _g_obj_nr)
		return (_g_obj_nr[obj,OBJ_PROP,prop_id])

	errorx("property '" _g_props[prop_id] "' (" prop_id ") not " \
	    "previously set on " obj_to_string(obj))
}

# Return the line (NR) at which a given property was set on the object
# Will throw an error if the property has not been set on obj
function obj_get_prop_nr(obj, prop) {
	return (obj_get_prop_id_nr(obj, prop[PROP_ID]))
}

# Return an abstract property ID for a given property
function obj_get_prop_id(obj, prop) {
	if (obj == null)
		errorx("obj_get_prop_id() on null object")

	return (class_get_prop_id(obj_get_class(obj), prop))
}


# Return the property ID for a given property name
function obj_get_named_prop_id(obj, name) {
	if (obj == null)
		errorx("obj_get_named_prop_id() on null object")

	return (class_get_named_prop_id(obj_get_class(obj), name))
}

# Set a property on obj
function set(obj, prop, value, _class) {
	return (prop_set(obj, prop[PROP_ID], value))
}

# Get a property value defined on obj
function get(obj, prop, _class) {
	return (prop_get(obj, prop[PROP_ID]))
}

# Set a property on obj, using a property ID returned by obj_get_prop_id() or
# class_get_prop_id()
function prop_set(obj, prop_id, value, _class) {
	if (obj == null) {
		errorx("setting property '" _g_props[prop_id] \
		    "' on null object")
	}

	_class = obj_get_class(obj)
	if (_class == null)
		errorx(obj " has no superclass")

	if (!class_has_prop_id(_class, prop_id)) {
		errorx("requested undefined property '" _g_props[prop_id] \
		    "' (" prop_id ") on " class_get_name(_class))
	}

	# Track the line on which the property was set
	_g_obj_nr[obj,OBJ_PROP,prop_id] = NR
	_g_obj[obj,OBJ_PROP,prop_id] = value
}

# Convert a property ID to a property path.
function prop_id_to_path(prop_id) {
	if (!(prop_id in _g_props))
		errorx("'" prop_id "' is not a property ID")

	# Convert to path string representation
	return (""prop_id)
}

# Convert a property to a property path.
function prop_to_path(prop) {
	if (!(PROP_ID in prop))
		errorx("prop_to_path() called with non-property head")

	return (prop_id_to_path(prop[PROP_ID]))
}

# Create a property path from head and tail properties
# Additional properties may be appended via prop_path_append() or
# prop_path_append_id()
function prop_path_create(head, tail) {
	if (!(PROP_ID in head))
		errorx("prop_path() called with non-property head")

	if (!(PROP_ID in tail))
		errorx("prop_path() called with non-property tail")

	return (head[PROP_ID] SUBSEP tail[PROP_ID])
}

# Append a property to the given property path
function prop_path_append(path, tail) {
	if (!(PROP_ID in tail))
		errorx("prop_path_append() called with non-property tail")

	return (prop_path_append_id(path, tail[PROP_ID]))
}

# Append a property ID to the given property path
function prop_path_append_id(path, tail_id) {
	if (!(tail_id in _g_props))
		errorx("'" tail_id "' is not a property ID")

	return (path SUBSEP tail_id)
}

# Fetch a value from obj using a property path previously returned by
# prop_path_create(), prop_to_path(), etc.
function prop_get_path(obj, prop_path, _class, _prop_ids, _nprop_ids, _next,
    _prop_head, _prop_len, _prop_tail)
{
	if (obj == null) {
		errorx("requested property path '" \
		    gsub(SUBSEP, ".", prop_path)  "' on null object")
	}

	# Try the cache first
	_class = obj_get_class(obj)
	if ((_class,prop_path,PPATH_HEAD) in _g_ppath_cache) {
		_prop_head = _g_ppath_cache[_class,prop_path,PPATH_HEAD]
		_next = prop_get(obj, _prop_head)

		if ((_class,prop_path,PPATH_TAIL) in _g_ppath_cache) {
			_prop_tail = _g_ppath_cache[_class,prop_path,PPATH_TAIL]
			return (prop_get_path(_next, _prop_tail))
		}

		return (_next)
	}

	# Parse the head/tail of the property path and add to cache
	_nprop_ids = split(prop_path, _prop_ids, SUBSEP)
	if (_nprop_ids == 0)
		errorx("empty property path")
	_prop_head = _prop_ids[1]
	_g_ppath_cache[_class,prop_path,PPATH_HEAD] = _prop_head

	if (_nprop_ids > 1) {
		_prop_len = length(_prop_head)
		_prop_tail = substr(prop_path, _prop_len+2)

		# Add to cache
		_g_ppath_cache[_class,prop_path,PPATH_TAIL] = _prop_tail
	}

	# Recursively call out implementation, this time fetching from
	# cache
	return (prop_get_path(obj, prop_path))
}

# Fetch a value property value from obj, using a property ID returned by
# obj_get_prop_id() or class_get_prop_id()
function prop_get(obj, prop_id, _class) {
	if (obj == null) {
		errorx("requested property '" _g_props[prop_id] \
		    "' on null object")
	}

	_class = obj_get_class(obj)
	if (_class == null)
		errorx(obj " has no superclass")

	if (!class_has_prop_id(_class, prop_id)) {
		errorx("requested undefined property '" _g_props[prop_id] \
		    "' (" prop_id ") on " class_get_name(_class))
	}

	return (_g_obj[obj,OBJ_PROP,prop_id])
}

# Create a new MacroType instance
function macro_type_new(name, const_suffix, _obj) {
	_obj = obj_new(MacroType)

	set(_obj, p_name, name)
	set(_obj, p_const_suffix, const_suffix)

	return (_obj)
}

# Create a new MacroDefine instance
function macro_new(name, value, _obj) {
	_obj = obj_new(MacroDefine)
	set(_obj, p_name, name)
	set(_obj, p_value, value)

	return (_obj)
}

# Create an empty array; this uses _g_arrays to store integer
# keys/values under the object's property prefix.
function array_new(_obj) {
	_obj = obj_new(Array)
	set(_obj, p_count, 0)

	return (_obj)
}

# Return the number of elements in the array
function array_size(array) {
	obj_assert_class(array, Array)
	return (get(array, p_count))
}

# Return true if the array is empty
function array_empty(array) {
	return (array_size(array) == 0)
}

# Append a value to the array
function array_append(array, value, _i) {
	obj_assert_class(array, Array)

	_i = get(array, p_count)
	_g_arrays[array,OBJ_PROP,_i] = value
	set(array, p_count, _i+1)
}

# Set an array value
# An error will be thrown if the idx is outside array bounds
function array_set(array, idx, value) {
	obj_assert_class(array, Array)

	if (!((array,OBJ_PROP,idx) in _g_arrays))
		errorx(idx " out of range of array " obj_to_string(array))

	_g_arrays[array,OBJ_PROP,idx] = value
}

# Return value at the given index from the array
# An error will be thrown if 'idx' is outside the array bounds
function array_get(array, idx) {
	obj_assert_class(array, Array)

	if (!((array,OBJ_PROP,idx) in _g_arrays))
		errorx(idx " out of range of array " obj_to_string(array))

	return (_g_arrays[array,OBJ_PROP,idx])
}


#
# Sort an array, using standard awk comparison operators over its values.
#
# If `prop_path*` is non-NULL, the corresponding property path (or property ID)
# will be fetched from each array element and used as the sorting value.
#
# If multiple property paths are specified, the array is first sorted by
# the first path, and then any equal values are sorted by the second path,
# and so on.
#
function array_sort(array, prop_path0, prop_path1, prop_path2, _size) {
	obj_assert_class(array, Array)

	if (_size != null)
		errorx("no more than three property paths may be specified")

	_size = array_size(array)
	if (_size <= 1)
		return

	_qsort(array, prop_path0, prop_path1, prop_path2, 0, _size-1)
}

function _qsort_get_key(array, idx, prop_path, _v) {
	_v = array_get(array, idx)
	
	if (prop_path == null)
		return (_v)

	return (prop_get_path(_v, prop_path))
}

function _qsort_compare(array, lhs_idx, rhs_val, ppath0, ppath1, ppath2,
    _lhs_val, _rhs_prop_val)
{
	_lhs_val = _qsort_get_key(array, lhs_idx, ppath0)
	if (ppath0 == null)
		_rhs_prop_val = rhs_val
	else
		_rhs_prop_val = prop_get_path(rhs_val, ppath0)

	if (_lhs_val == _rhs_prop_val && ppath1 != null) {
		_lhs_val = _qsort_get_key(array, lhs_idx, ppath1)
		_rhs_prop_val = prop_get_path(rhs_val, ppath1)

		if (_lhs_val == _rhs_prop_val && ppath2 != null) {
			_lhs_val = _qsort_get_key(array, lhs_idx, ppath2)
			_rhs_prop_val = prop_get_path(rhs_val, ppath2)
		}
	}

	if (_lhs_val < _rhs_prop_val)
		return (-1)
	else if (_lhs_val > _rhs_prop_val)
		return (1)
	else
		return (0)
}

function _qsort(array, ppath0, ppath1, ppath2, first, last, _qpivot,
    _qleft, _qleft_val, _qright, _qright_val)
{
	if (first >= last)
		return

	# select pivot element
	_qpivot = int(first + int((last-first+1) * rand()))
	_qleft = first
	_qright = last

	_qpivot_val = array_get(array, _qpivot)

	# partition
	while (_qleft <= _qright) {
		while (_qsort_compare(array, _qleft, _qpivot_val, ppath0, ppath1,
		    ppath2) < 0)
		{
			_qleft++
		}

		while (_qsort_compare(array, _qright, _qpivot_val, ppath0, ppath1,
		    ppath2) > 0)
		{
			_qright--
		}

		# swap
		if (_qleft <= _qright) {
			_qleft_val = array_get(array, _qleft)
			_qright_val = array_get(array, _qright)
			
			array_set(array, _qleft, _qright_val)
			array_set(array, _qright, _qleft_val)

			_qleft++
			_qright--
		}
	}

	# sort the partitions
	_qsort(array, ppath0, ppath1, ppath2, first, _qright)
	_qsort(array, ppath0, ppath1, ppath2, _qleft, last)
}


#
# Join all array values with the given separator
#
# If `prop_path` is non-NULL, the corresponding property path (or property ID)
# will be fetched from each array value and included in the result, rather than
# immediate array value
#
function array_join(array, sep, prop_path, _i, _size, _value, _result) {
	obj_assert_class(array, Array)

	_result = ""
	_size = array_size(array)
	for (_i = 0; _i < _size; _i++) {
		# Fetch the value (and optionally, a target property)
		_value = array_get(array, _i)
		if (prop_path != null)
			_value = prop_get_path(_value, prop_path)

		if (_i+1 < _size)
			_result = _result _value sep
		else
			_result = _result _value
	}

	return (_result)
}

# Return the first value in the array, or null if empty
function array_first(array) {
	obj_assert_class(array, Array)

	if (array_size(array) == 0)
		return (null)
	else 
		return (array_get(array, 0))
}

# Return the last value in the array, or null if empty
function array_tail(list, _size) {
	obj_assert_class(array, Array)

	_size = array_size(array)
	if (_size == 0)
		return (null)
	else 
		return (array_get(array, _size-1))
}

# Create an empty hash table; this uses the _g_maps array to store arbitrary
# keys/values under the object's property prefix.
function map_new(_obj) {
	_obj = obj_new(Map)
	return (_obj)
}

# Add `key` with `value` to `map`
function map_set(map, key, value) {
	obj_assert_class(map, Map)
	_g_maps[map,OBJ_PROP,key] = value
}

# Remove `key` from the map
function map_remove(map, key) {
	obj_assert_class(map, Map)
	delete _g_maps[map,OBJ_PROP,key]
}

# Return true if `key` is found in `map`, false otherwise
function map_contains(map, key) {
	obj_assert_class(map, Map)
	return ((map,OBJ_PROP,key) in _g_maps)
}

# Fetch the value of `key` from the map. Will throw an error if the
# key does not exist
function map_get(map, key) {
	obj_assert_class(map, Map)
	return _g_maps[map,OBJ_PROP,key]
}

# Create and return a new list containing all defined values in `map`
function map_to_array(map, _key, _prefix, _values) {
	obj_assert_class(map, Map)

	_values = array_new()
	_prefix = "^" map SUBSEP OBJ_PROP SUBSEP
	for (_key in _g_maps) {
		if (!match(_key, _prefix))
			continue

		array_append(_values, _g_maps[_key])
	}

	return (_values)
}

# Create a new Type instance
function type_new(name, width, signed, constant, array_constant, fmt, mask,
    constant_value, array_constant_value, _obj)
{
	obj_assert_class(fmt, Fmt)

	_obj = obj_new(Type)
	set(_obj, p_name, name)
	set(_obj, p_width, width)
	set(_obj, p_signed, signed)
	set(_obj, p_const, constant)
	set(_obj, p_const_val, constant_value)
	set(_obj, p_array_const, array_constant)
	set(_obj, p_array_const_val, array_constant_value)
	set(_obj, p_default_fmt, fmt)
	set(_obj, p_mask, mask)

	return (_obj)
}

# Return true if two types are equal
function type_equal(lhs, rhs) {
	# Simple case
	if (lhs == rhs)
		return (1)

	# Must share a common class
	if (obj_get_class(lhs) != obj_get_class(rhs))
		return (0)

	# Handle ArrayType equality
	if (obj_is_instanceof(lhs, ArrayType)) {
		# Size must be equal
		if (get(lhs, p_count) != get(rhs, p_count))
			return (0)

		# The base types must be equal
		return (type_equal(type_get_base(lhs), type_get_base(rhs)))
	}

	# Handle Type equality -- we just check for trivial identity
	# equality of all members
	obj_assert_class(lhs, Type)
	return (obj_trivially_equal(lhs, rhs))
}

# Return the type's default value mask. If the type is an array type,
# the default mask of the base type will be returned.
function type_get_default_mask(type) {
	if (obj_is_instanceof(type, ArrayType))
		return (type_get_default_mask(type_get_base(type)))

	obj_assert_class(type, Type)
	return (get(type, p_mask))
}

# Return the type's C constant representation
function type_get_const(type) {
	if (obj_is_instanceof(type, ArrayType))
		return (get(type_get_base(type), p_array_const))

	obj_assert_class(type, Type)
	return (get(type, p_const))
}

# Return the type's C constant integer value
function type_get_const_val(type) {
	if (obj_is_instanceof(type, ArrayType))
		return (get(type_get_base(type), p_array_const_val))

	obj_assert_class(type, Type)
	return (get(type, p_const_val))
}

# Return an array type's element count, or 1 if the type is not
# an array type
function type_get_nelem(type) {
	if (obj_is_instanceof(type, ArrayType))
		return (get(type, p_count))

	obj_assert_class(type, Type)
	return (1)
}

# Return the base type for a given type instance.
function type_get_base(type) {
	if (obj_is_instanceof(type, ArrayType))
		return (type_get_base(get(type, p_type)))

	obj_assert_class(type, Type)
	return (type)
}

# Return the default fmt for a given type instance
function type_get_default_fmt(type, _base, _fmt, _array_fmt) {
	_base = type_get_base(type)
	_fmt = get(_base, p_default_fmt)

	if (obj_is_instanceof(type, ArrayType)) {
		_array_fmt = get(_fmt, p_array_fmt)
		if (_array_fmt != null)
			_fmt = _array_fmt
	}

	return (_fmt)
}

# Return a string representation of the given type
function type_to_string(type, _base_type) {
	if (obj_is_instanceof(type, ArrayType)) {
		_base_type = type_get_base(type)
		return (type_to_string(_base_type) "[" get(type, p_count) "]")
	}
	return get(type, p_name)
}

# Return true if type `rhs` is can be coerced to type `lhs` without data
# loss
function type_can_represent(lhs, rhs) {
	# Must be of the same class (Type or ArrayType)
	if (obj_get_class(lhs) != obj_get_class(rhs))
		return (0)

	if (obj_is_instanceof(lhs, ArrayType)) {
		# The base types must have a representable relationship
		if (!type_can_represent(type_get_base(lhs), type_get_base(rhs)))
			return (0)

		# The lhs type must be able to represent -at least- as
		# many elements as the RHS type
		if (get(lhs, p_count) < get(rhs, p_count))
			return (0)

		return (1)
	}

	# A signed type could represent the full range of a smaller unsigned
	# type, but we don't bother; the two should agree when used in a SROM
	# layout. Instead simply assert that both are signed or unsigned.
	if (get(lhs, p_signed) != get(rhs, p_signed))
		return (0)

	# The `rhs` type must be equal or smaller in width to the `lhs` type
	if (get(lhs, p_width) < get(rhs, p_width))
		return (0)

	return (1)
}

# Create a new ArrayType instance
function array_type_new(type, count, _obj) {
	_obj = obj_new(ArrayType)
	set(_obj, p_type, type)
	set(_obj, p_count, count)

	return (_obj)
}

#
# Parse a type string to either the Type, ArrayType, or null if
# the type is not recognized.
#
function parse_type_string(str, _base, _count) {
	if (match(str, ARRAY_REGEX"$") > 0) {
		# Extract count and base type
		_count = substr(str, RSTART+1, RLENGTH-2)
		sub(ARRAY_REGEX"$", "", str)

		# Look for base type
		if ((_base = type_named(str)) == null)
			return (null)

		return (array_type_new(_base, int(_count)))
	} else {
		return (type_named(str))
	}
}

#
# Parse a variable name in the form of 'name' or 'name[len]', returning
# either the provided base_type if no array specifiers are found, or
# the fully parsed ArrayType.
#
function parse_array_type_specifier(str, base_type, _count) {
	if (match(str, ARRAY_REGEX"$") > 0) {
		# Extract count
		_count = substr(str, RSTART+1, RLENGTH-2)
		return (array_type_new(base_type, int(_count)))
	} else {
		return (base_type)
	}
}

# Return the type constant for `name`, if any
function type_named(name, _n, _type) {
	if (name == null)
		errorx("called type_named() with null name")

	if (map_contains(BaseTypes, name))
		return (map_get(BaseTypes, name))

	return (null)	
}

# Create a new Fmt instance
function fmt_new(name, symbol, array_fmt, _obj) {
	_obj = obj_new(Fmt)
	set(_obj, p_name, name)
	set(_obj, p_symbol, symbol)

	if (array_fmt != null)
		set(_obj, p_array_fmt, array_fmt)

	return (_obj)
}


# Return the Fmt constant for `name`, if any
function fmt_named(name, _n, _fmt) {
	if (map_contains(ValueFormats, name))
		return (map_get(ValueFormats, name))

	return (null)
}

# Create a new VFlag instance
function vflag_new(name, constant, _obj) {
	_obj = obj_new(VFlag)
	set(_obj, p_name, name)
	set(_obj, p_const, constant)

	return (_obj)
}

# Create a new StringConstant AST node
function stringconstant_new(value, continued, _obj) {
	_obj = obj_new(StringConstant)
	set(_obj, p_value, value)
	set(_obj, p_continued, continued)
	set(_obj, p_line, NR)

	return (_obj)
}

# Create an empty StringConstant AST node to which additional lines
# may be appended
function stringconstant_empty(_obj) {
	return (stringconstant_new("", 1))
}

# Parse an input string and return a new string constant
# instance
function stringconstant_parse_line(line, _obj) {
	_obj = stringconstant_empty()
	stringconstant_append_line(_obj, line)
	return (_obj)
}

# Parse and apend an additional line to this string constant
function stringconstant_append_line(str, line, _cont, _strbuf, _regex, _eol) {
	obj_assert_class(str, StringConstant)

	# Must be marked for continuation
	if (!get(str, p_continued)) {
		errorx("can't append to non-continuation string '" \
		    get(str, p_value) "'")
	}

	_strbuf = get(str, p_value)

	# If start of string, look for (and remove) initial double quote
	if (_strbuf == null) {
		_regex = "^[ \t]*\""
		if (!sub(_regex, "", line)) {
			error("expected quoted string")
		}
	}

	# Look for a terminating double quote
	_regex = "([^\"\\\\]*(\\\\.[^\"\\\\]*)*)\""

	_eol = match(line, _regex)
	if (_eol > 0) {
		# Drop everything following the terminating quote
		line = substr(line, 1, RLENGTH-1)
		_cont = 0
	} else {
		# No terminating quote found, continues on next line
		_cont = 1
	}

	# Trim leading and trailing whitespace
	sub(/(^[ \t]+|[ \t]+$)/, "", line)

	# Append to existing buffer
	if ((_strbuf = get(str, p_value)) == NULL)
		set(str, p_value, line)
	else
		set(str, p_value, _strbuf " " line)

	# Update line continuation setting
	set(str, p_continued, _cont)
}

# Create a new RevRange instance
function revrange_new(start, end, _obj) {
	_obj = obj_new(RevRange)
	set(_obj, p_start, start)
	set(_obj, p_end, end)
	set(_obj, p_line, NR)

	return (_obj)
}

# Return true if the two revision ranges are equal
function revrange_equal(lhs, rhs) {
	if (get(lhs, p_start) != get(rhs, p_start))
		return (0)

	if (get(lhs, p_end) != get(rhs, p_end))
		return (0)

	return (1)
}

# Return true if the requested rev is covered by revrange, false otherwise
function revrange_contains(range, rev) {
	obj_assert_class(range, RevRange)

	if (rev < get(range, p_start))
		return (0)
	else if (rev > get(range, p_end)) {
		return (0)
	} else {
		return (1)
	}
}

#
# Return a string representation of the given revision range
#
function revrange_to_string(revs, _start, _end) {
	obj_assert_class(revs, RevRange)

	_start = get(revs, p_start)
	_end = get(revs, p_end)

	if (_start == 0)
		return ("<= " _end)
	else if (_end == REV_MAX)
		return (">= " _start)
	else
		return (_start "-" _end)
}

# Create a new VarGroup instance
function var_group_new(name, _obj) {
	_obj = obj_new(VarGroup)
	set(_obj, p_name, name)
	set(_obj, p_vars, array_new())
	set(_obj, p_line, NR)

	return (_obj)
}

# Create a new NVRAM instance
function nvram_new(_obj, _vars, _v) {
	_obj = obj_new(NVRAM)
	_vars = array_new()
	set(_obj, p_vars, _vars)
	set(_obj, p_var_groups, array_new())
	set(_obj, p_srom_layouts, array_new())
	set(_obj, p_srom_table, map_new())

	#
	# Register our implicit variable definitions
	#

	# SROM signature offset
	_v = var_new(VAccessInternal, "<sromsig>", UInt16)
	array_append(_vars, _v)
	_g_var_names[get(_v, p_name)] = _v

	# SROM CRC8 offset
	_v = var_new(VAccessInternal, "<sromcrc>", UInt8)
	array_append(_vars, _v)
	_g_var_names[get(_v, p_name)] = _v

	return (_obj)
}

# Register a new SROM layout instance
# An error will be thrown if the layout overlaps any revisions covered
# by an existing instance.
function nvram_add_srom_layout(nvram, layout, _table, _revs, _start, _end, _i) {
	obj_assert_class(nvram, NVRAM)
	obj_assert_class(layout, SromLayout)

	# revision:layout hash table
	_table = get(nvram, p_srom_table)

	# register the layout's revisions
	_revs = get(layout, p_revisions)
	_start = get(_revs, p_start)
	_end = get(_revs, p_end)

	for (_i = _start; _i <= _end; _i++) {
		if (map_contains(_table, _i)) {
			error("SROM layout redeclares layout for revision '" \
			    _i "' (originally declared on line " \
			    get(map_get(_table, _i), p_line) ")")
		}

		map_set(_table, _i, layout)
	}

	# append to srom_layouts
	array_append(get(nvram, p_srom_layouts), layout)
}

# Return the first SROM layout registered for a given SROM revision,
# or null if no matching layout is found
function nvram_get_srom_layout(nvram, revision, _layouts, _nlayouts, _layout,
    _i)
{
	obj_assert_class(nvram, NVRAM)

	_layouts = get(nvram, p_srom_layouts)
	_nlayouts = array_size(_layouts)
	for (_i = 0; _i < _nlayouts; _i++) {
		_layout = array_get(_layouts, _i)

		if (srom_layout_has_rev(_layout, revision))
			return (_layout)
	}

	# Not found
	return (null)
}

# Create a new Var instance
function var_new(access, name, type, _obj) {
	obj_assert_class(access, VAccess)

	# Validate the variable identifier
	#
	# The access modifier dictates the permitted identifier format.
	#   VAccessInternal:		<ident>
	#   VAccess(Public|Private):	ident
	if (access != VAccessInternal && name ~ SVAR_IDENT_REGEX) {
		error("invalid identifier '"name"'; did you mean to " \
		    "mark this variable as internal?")
	} else if (access == VAccessInternal) {
		if (name !~ SVAR_IDENT_REGEX)
			error("invalid identifier '"name"' for internal " \
			"variable; did you mean '<" name ">'?")
	} else if (name !~ VAR_IDENT_REGEX) {
		error("invalid identifier '"name"'")
	}

	_obj = obj_new(Var)
	set(_obj, p_access, access)
	set(_obj, p_name, name)
	set(_obj, p_type, type)
	set(_obj, p_line, NR)

	return (_obj)
}

# Return true if var is internal-only, and should not be included
# in any output (e.g. has an access specifier of VAccessInternal).
function var_is_internal(var) {
	return (get(var, p_access) == VAccessInternal)
}

# Return true if `var` has an array type
function var_has_array_type(var, _vtype) {
	obj_assert_class(var, Var)
	_vtype = get(var, p_type)
	return (obj_is_instanceof(_vtype, ArrayType))
}

# Return the number of array elements defined by this variable's type,
# or 1 if the variable does not have an array type.
function var_get_array_len(var) {
	obj_assert_class(var, Var)
	return (type_get_nelem(get(var, p_type)))
}

# Return the fmt for var. If not explicitly set on var, will return then
# return of calling type_get_default_fmt() with the variable's type
function var_get_fmt(var, _fmt) {
	obj_assert_class(var, Var)

	# If defined on var, return it
	if ((_fmt = get(var, p_fmt)) != null)
		return (_fmt)

	# Fall back on the type's default
	return (type_get_default_fmt(get(var, p_type)))
}

# Return a new MacroDefine instance for the given variable, macro type,
# and value
function var_get_macro(var, macro_type, value, _macro) {
	obj_assert_class(var, Var)
	obj_assert_class(macro_type, MacroType)

	return (macro_new(var_get_macro_name(var, macro_type), value))
}

# Return the preprocessor constant name to be used with `var` for the given
# macro_type
function var_get_macro_name(var, macro_type, _var_name, _suffix) {
	obj_assert_class(var, Var)
	obj_assert_class(macro_type, MacroType)

	_var_name = get(var, p_name)
	_suffix = get(macro_type, p_const_suffix)

	return("BHND_NVAR_" toupper(_var_name) _suffix)
}

# Create a new SromLayout instance
function srom_layout_new(rev_desc, _obj)
{
	_obj = obj_new(SromLayout)
	set(_obj, p_revisions, rev_desc)
	set(_obj, p_entries, array_new())
	set(_obj, p_revmap, map_new())
	set(_obj, p_output_var_counts, map_new())
	set(_obj, p_line, NR)

	return (_obj)
}

# Register a new entry with the srom layout
function srom_layout_add_entry(layout, entry, _revmap, _name, _rev_start,
    _rev_end, _var, _prev_entry, _count, _i)
{
	obj_assert_class(layout, SromLayout)
	obj_assert_class(entry, SromEntry)

	_layout_revmap = get(layout, p_revmap)
	_layout_var_count = get(layout, p_output_var_counts)

	_var = get(entry, p_var)
	_name = get(_var, p_name)

	# Add to revision array
	array_append(get(layout, p_entries), entry)

	# Add to the revision map tables
	_rev_start = get(get(entry, p_revisions), p_start)
	_rev_end = get(get(entry, p_revisions), p_end)

	for (_i = _rev_start; _i <= _rev_end; _i++) {
		# Check for existing entry
		_prev_entry = srom_layout_find_entry(layout, _name, _i)
		if (_prev_entry != null) {
			error("redefinition of variable '" _name "' for SROM " \
			    "revision " _i " (previously defined on line " \
			    get(_prev_entry, p_line) ")")
		}

		# Add to the (varname,revision) map
		map_set(_layout_revmap, (_name SUBSEP _i), entry)

		# If an output variable, set or increment the output variable
		# count
		if (!srom_entry_should_output(entry, _i))
			continue

		if (!map_contains(_layout_var_count, _i)) {
			map_set(_layout_var_count, _i, 1)
		} else {
			_count = map_get(_layout_var_count, _i)
			map_set(_layout_var_count, _i, _count + 1)
		}
	}
}


# Return the variable name to be used when emitting C declarations
# for this SROM layout
#
# The name is gauranteed to be unique across SROM layouts with non-overlapping
# revision ranges
function srom_layout_get_variable_name(layout, _revs) {
	obj_assert_class(layout, SromLayout)

	_revs = get(layout, p_revisions)

	return ("bhnd_sprom_layout_r" get(_revs, p_start) \
	    "_r" get(_revs, p_end))
}

# Return true if the given SROM revision is defined by the layout, false
# otherwise
function srom_layout_has_rev(layout, rev) {
	obj_assert_class(layout, SromLayout)
	return (revrange_contains(get(layout, p_revisions), rev))
}


# Return the total number of output variables (variables to be included
# in the SROM layout bindings) for the given SROM revision
function srom_layout_num_output_vars(layout, rev, _counts)
{
	obj_assert_class(layout, SromLayout)

	_counts = get(layout, p_output_var_counts)
	if (!map_contains(_counts, rev))
		return (0)

	return (map_get(_counts, rev))
}

# Return the SromEntry defined for the given variable name and SROM revision,
# or null if none
function srom_layout_find_entry(layout, vname, revision, _key, _srom_revmap) {
	obj_assert_class(layout, SromLayout)

	_srom_revmap = get(layout, p_revmap)

	# SromEntry are mapped by name,revision composite keys
	_key = vname SUBSEP revision
	if (!map_contains(_srom_revmap, _key))
		return (null)

	return (map_get(_srom_revmap, _key))
	
}

# Create a new SromLayoutFilter instance, checking that `revs`
# falls within the parent's revision range
function srom_layout_filter_new(parent, revs, _obj, _start, _end, _parent_revs) {
	obj_assert_class(parent, SromLayout)
	obj_assert_class(revs, RevRange)

	# Fetch our parent's revision range, confirm that we're
	# a strict subset
	_start = get(revs, p_start)
	_end = get(revs, p_end)
	_parent_revs = get(parent, p_revisions)

	if (!revrange_contains(_parent_revs, _start))
		error("'" _start "' is outside of parent range")

	if (!revrange_contains(_parent_revs, _end))
		error("'" _end "' is outside of parent range")

	if (revrange_equal(revs, _parent_revs)) {
		error("srom range '" revrange_to_string(revs) "' is " \
		    "identical to parent range of '" \
		        revrange_to_string(_parent_revs) "'")
	}

	# Construct and return new filter instance
	_obj = obj_new(SromLayoutFilter)
	set(_obj, p_parent, parent)
	set(_obj, p_revisions, revs)
	set(_obj, p_line, NR)

	return (_obj)
}

#
# Create a new SromEntry instance
#
# var:		The variable referenced by this entry
# revisions:	The SROM revisions to which this entry applies
# base_offset:	The SROM entry offset; any relative segment offsets will be
#		calculated relative to the base offset
# type:		The SROM's value type; this may be a subtype of the variable
#		type, and defines the data (width, sign, etc) to be read from
#		SROM.
# 
function srom_entry_new(var, revisions, base_offset, type, _obj) {
	obj_assert_class(var, Var)
	if (revisions != null)
		obj_assert_class(revisions, RevRange)

	_obj = obj_new(SromEntry)
	set(_obj, p_var, var)
	set(_obj, p_revisions, revisions)
	set(_obj, p_base_offset, base_offset)
	set(_obj, p_type, type)
	set(_obj, p_offsets, array_new())
	set(_obj, p_line, NR)

	return (_obj)
}

# Return true if the SromEntry has an array type
function srom_entry_has_array_type(entry) {
	obj_assert_class(entry, SromEntry)

	return (obj_is_instanceof(get(entry, p_type), ArrayType))
}

# Return the number of array elements defined by this SromEntry's type,
# or 1 if the entry does not have an array type.
function srom_entry_get_array_len(entry, _type) {
	obj_assert_class(entry, SromEntry)

	return (type_get_nelem(get(entry, p_type)))
}

#
# Return true if the given entry should be included in the output bindings
# generated for the given revision, false otherwise.
#
function srom_entry_should_output(entry, rev, _var, _revs)
{
	obj_assert_class(entry, SromEntry)

	_var = get(entry, p_var)
	_revs = get(entry, p_revisions)

	# Exclude internal variables
	if (var_is_internal(_var))
		return (0)

	# Exclude inapplicable entry revisions
	if (!revrange_contains(_revs, rev))
		return (0)

	return (1)
}

#
# Return the single, non-shifted, non-masked offset/segment for the given
# SromEntry, or throw an error if the entry contains multiple offsets/segments.
#
# This is used to fetch special-cased variable definitions that are required
# to present a single simple offset.
#
function srom_entry_get_single_segment(entry, _offsets, _segments, _seg,
    _base_type, _default_mask)
{
	obj_assert_class(entry, SromEntry)

	# Fetch the single offset's segment list
	_offsets = get(entry, p_offsets)
	if (array_size(_offsets) != 1)
		errorc(get(entry, p_line), "unsupported offset count")

	_segments = get(array_first(_offsets), p_segments)
	if (array_size(_segments) != 1)
		errorc(get(entry, p_line), "unsupported segment count")

	# Fetch the single segment
	_seg = array_first(_segments)
	_base_type = srom_segment_get_base_type(_seg)
	_default_mask = get(_base_type, p_mask)

	# Must not be shifted/masked
	if (get(_seg, p_shift) != 0)
		errorc(obj_get_prop_nr(_seg, p_mask), "shift unsupported")

	if (get(_seg, p_mask) != _default_mask)
		errorc(obj_get_prop_nr(_seg, p_mask), "mask unsupported")	

	return  (_seg)
}

# Create a new SromOffset instance
function srom_offset_new(_obj) {
	_obj = obj_new(SromOffset)
	set(_obj, p_segments, array_new())
	set(_obj, p_line, NR)

	return (_obj)
}

# Return the number of SromSegment instances defined by this offset.
function srom_offset_segment_count(offset) {
	obj_assert_class(offset, SromOffset)
	return (array_size(get(offset, p_segments)))
}

# Return the idx'th segment. Will throw an error if idx falls outside
# the number of available segments.
function srom_offset_get_segment(offset, idx, _segments, _seg) {
	obj_assert_class(offset, SromOffset)

	return (array_get(get(offset, p_segments), idx))
}

# Create a new SromSegment instance
function srom_segment_new(offset, type, mask, shift, value, _obj) {
	_obj = obj_new(SromSegment)
	set(_obj, p_offset, offset)
	set(_obj, p_type, type)
	set(_obj, p_mask, mask)
	set(_obj, p_shift, shift)
	set(_obj, p_value, value)
	set(_obj, p_line, NR)

	return (_obj)
}

# Return true if the segment has an array type
function srom_segment_has_array_type(seg, _type) {
	_type = srom_segment_get_type(seg)
	return (obj_is_instanceof(_type, ArrayType))
}

# Return the array count of the segment, or 1 if the segment does not have
# an array type 
function srom_segment_get_array_len(seg, _type) {
	if (!srom_segment_has_array_type(seg))
		return (1)

	_type = srom_segment_get_type(seg)
	return (get(_type, p_count))
}

# Return the type of the segment
function srom_segment_get_type(seg) {
	obj_assert_class(seg, SromSegment)
	return (get(seg, p_type))

}

# Return the base type of the segment
function srom_segment_get_base_type(seg) {
	return (type_get_base(srom_segment_get_type(seg)))
}

# Return true if the two segments have identical types and attributes (i.e.
# differing only by offset)
function srom_segment_attributes_equal(lhs, rhs) {
	obj_assert_class(lhs, SromSegment)
	obj_assert_class(rhs, SromSegment)

	# type
	if (!type_equal(get(lhs, p_type), get(rhs, p_type)))
		return (0)

	# mask
	if (get(lhs, p_mask) != get(rhs, p_mask))
		return (0)

	# shift
	if (get(lhs, p_shift) != get(rhs, p_shift))
		return (0)

	# value
	if (get(lhs, p_value) != get(rhs, p_value))
		return (0)

	return (1)
}

# Return a human-readable representation of a Segment instance
function segment_to_string(seg, _str, _t, _m, _s,  _attrs, _attr_str) {
	_attrs = array_new()

	# include type (if specified)
	if ((_t = get(seg, p_type)) != null)
		_str = (type_to_string(_t) " ")

	# include offset
	_str = (_str sprintf("0x%X", get(seg, p_offset)))

	# append list of attributes
	if ((_m = get(seg, p_mask)) != null)
		array_append(_attrs, ("&" _m))

	if ((_s = get(seg, p_shift)) != null) {
		if (_s > 0)
			_s = ">>" _s
		else
			_s = "<<" _s
		array_append(_attrs, _s)
	}

	_attr_str = array_join(_attrs, ", ")
	obj_delete(_attrs)

	if (_attr_str == "")
		return (_str)
	else
		return (_str " (" _attr_str ")")
}

# return the flag definition for variable `v`
function gen_var_flags(v, _type, _flags, _flag, _str)
{
	_num_flags = 0;
	_type = get(v, p_type)
	_flags = array_new()

	# VF_PRIVATE
	if (get(v, p_access) == VAccessPrivate)
		array_append(_flags, VFlagPrivate)

	# VF_IGNALL1
	if (get(v, p_ignall1))
		array_append(_flags, VFlagIgnoreAll1)

	# If empty, return empty flag value
	if (array_size(_flags) == 0) {
		obj_delete(_flags)
		return ("0")
	}

	# Join all flag constants with |
	_str = array_join(_flags, "|", class_get_prop_id(VFlag, p_const))

	# Clean up
	obj_delete(_flags)

	return (_str)
}

#
# Return the absolute value
#
function abs(i) {
	return (i < 0 ? -i : i)
}

#
# Return the minimum of two values
#
function min(lhs, rhs) {
	return (lhs < rhs ? lhs : rhs)
}

#
# Return the maximum of two values
#
function max(lhs, rhs) {
	return (lhs > rhs ? lhs : rhs)
}

#
# Parse a hex string
#
function parse_hex_string(str, _hex_pstate, _out, _p, _count) {
	if (!AWK_REQ_HEX_PARSING)
		return (str + 0)

	# Populate hex parsing lookup table on-demand
	if (!("F" in _g_hex_table)) {
		for (_p = 0; _p < 16; _p++) {
			_g_hex_table[sprintf("%X", _p)] = _p
			_g_hex_table[sprintf("%x", _p)] = _p
		}
	}

	# Split input into an array
	_count = split(toupper(str), _hex_pstate, "")
	_p = 1

	# Skip leading '0x'
	if (_count >= 2 && _hex_pstate[1] == "0") {
		if (_hex_pstate[2] == "x" || _hex_pstate[2] == "X")
			_p += 2
	}

	# Parse the hex_digits
	_out = 0
	for (; _p <= _count; _p++)
		_out = (_out * 16) + _g_hex_table[_hex_pstate[_p]]

	return (_out)
}

#
# Return the integer representation of an unsigned decimal, hexadecimal, or
# octal string
#
function parse_uint_string(str) {
	if (str ~ UINT_REGEX)
		return (int(str))
	else if (str ~ HEX_REGEX)
		return (parse_hex_string(str))
	else
		error("invalid integer value: '" str "'")
}

#
# Parse an offset string, stripping any leading '+' or trailing ':' or ','
# characters
#
# +0x0:
# 0x0,
# ...
#
function parse_uint_offset(str) {
	# Drop any leading '+'
	sub(/^\+/, "", str)

	# Drop any trailing ':', ',', or '|'
	sub("[,|:]$", "", str)

	# Parse the cleaned up string
	return (parse_uint_string(str))
}

#
# Print msg to output file, without indentation
#
function emit_ni(msg) {
	printf("%s", msg) >> OUTPUT_FILE
}

#
# Print msg to output file, indented for the current `output_depth`
#
function emit(msg, _ind) {
	for (_ind = 0; _ind < output_depth; _ind++)
		emit_ni("\t")

	emit_ni(msg)
}

#
# Print a warning to stderr
#
function warn(msg) {
	print "warning:", msg, "at", FILENAME, "line", NR > "/dev/stderr"
}

#
# Print an warning message without including the source line information
#
function warnx(msg) {
	print "warning:", msg > "/dev/stderr"
}

#
# Print a compiler error to stderr with a caller supplied
# line number
#
function errorc(line, msg) {
	errorx(msg " at " FILENAME " line " line)
}

#
# Print a compiler error to stderr
#
function error(msg) {
	errorx(msg " at " FILENAME " line " NR ":\n\t" $0)
}

#
# Print an error message without including the source line information
#
function errorx(msg) {
	print "error:", msg > "/dev/stderr"
	_EARLY_EXIT=1
	exit 1
}

#
# Print a debug output message
#
function debug(msg, _i) {
	if (!DEBUG)
		return
	for (_i = 1; _i < _g_parse_stack_depth; _i++)
		printf("\t") > "/dev/stderr"
	print msg > "/dev/stderr"
}

#
# Advance to the next non-comment input record
#
function next_line(_result) {
	do {
		_result = getline
	} while (_result > 0 && $0 ~ /^[ \t]*#.*/) # skip comment lines
	return (_result)
}

#
# Advance to the next input record and verify that it matches @p regex
#
function getline_matching(regex, _result) {
	_result = next_line()
	if (_result <= 0)
		return (_result)

	if ($0 ~ regex)
		return (1)

	return (-1)
}

#
# Shift the current fields left by `n`.
#
# If all fields are consumed and the optional do_getline argument is true,
# read the next line.
#
function shiftf(n, do_getline, _i) {
	if (n > NF)
		error("shift past end of line")

	if (n == NF) {
		# If shifting the entire line, just reset the line value
		$0 = ""
	} else {
		for (_i = 1; _i <= NF-n; _i++) {
			$(_i) = $(_i+n)
		}
		NF = NF - n
	}

	if (NF == 0 && do_getline)
		next_line()
}

# Push a new parser state.
function parser_state_push(ctx, is_block, _state) {
	_state = obj_new(ParseState)
	set(_state, p_ctx, ctx)
	set(_state, p_is_block, is_block)
	set(_state, p_line, NR)

	_g_parse_stack_depth++
	_g_parse_stack[_g_parse_stack_depth] = _state
}

# Fetch the current parser state
function parser_state_get() {
	if (_g_parse_stack_depth == 0)
		errorx("parser_state_get() called with empty parse stack")

	return (_g_parse_stack[_g_parse_stack_depth])
}

# Pop the current parser state
function parser_state_pop(_block_state, _closes_block) {
	if (_g_parse_stack_depth == 0)
		errorx("parser_state_pop() called with empty parse stack")

	_closes_block = get(parser_state_get(), p_is_block)

	delete _g_parse_stack[_g_parse_stack_depth]
	_g_parse_stack_depth--

	if (_closes_block)
		debug("}")
}

# Fetch the current context object associated with this parser state
# The object will be asserted as being an instance of the given class.
function parser_state_get_context(class, _ctx_obj) {
	_ctx_obj = get(parser_state_get(), p_ctx)
	obj_assert_class(_ctx_obj, class)

	return (_ctx_obj)
}

# Walk the parser state stack until a context object of the given class
# is found. If the top of the stack is reached without finding a context object
# of the requested type, an error will be thrown.
function parser_state_find_context(class, _state, _ctx, _i) {
	if (class == null)
		errorx("parser_state_find_context() called with null class")

	# Find the first context instance inheriting from `class`
	for (_i = 0; _i < _g_parse_stack_depth; _i++) {
		_state = _g_parse_stack[_g_parse_stack_depth - _i]
		_ctx = get(_state, p_ctx)

		# Check for match
		if (obj_is_instanceof(_ctx, class))
			return (_ctx)
	}

	# Not found
	errorx("no context instance of type '" class_get_name(class) "' " \
	    "found in parse stack")
}

#
# Find opening brace and push a new parser state for a brace-delimited block.
#
function parser_state_open_block(ctx) {
	if ($0 ~ "{" || getline_matching("^[ \t]*{") > 0) {
		parser_state_push(ctx, 1)
		sub("^[^{]*{", "", $0)
		return
	}

	error("found '"$1 "' instead of expected '{'")
}

#
# Find closing brace and pop parser states until the first
# brace-delimited block is discarded.
#
function parser_state_close_block(_next_state, _found_block) {
	if ($0 !~ "}")
		error("internal error - no closing brace")

	# pop states until we exit the first enclosing block
	do {
		_next_state = parser_state_get()
		_found_block = get(_next_state, p_is_block)
		parser_state_pop()
	} while (!_found_block)

	# strip everything prior to the block closure
	sub("^[^}]*}", "", $0)
}

# Evaluates to true if the current parser state is defined with a context of
# the given class
function in_parser_context(class, _ctx) {
	if (class == null)
		errorx("called in_parser_context() with null class")

	_ctx = get(parser_state_get(), p_ctx)
	return (obj_is_instanceof(_ctx, class))
}

#
# Parse and return a revision range from the current line.
#
# 4
# 4-10	# revisions 4-10, inclusive
# > 4
# < 4
# >= 4
# <= 4
#
function parse_revrange(_start, _end, _robj) {
	_start = 0
	_end = 0

	if ($2 ~ "[0-9]*-[0-9*]") {
		split($2, _g_rev_range, "[ \t]*-[ \t]*")
		_start = int(_g_rev_range[1])
		_end = int(_g_rev_range[2])
	} else if ($2 ~ "(>|>=|<|<=)" && $3 ~ "[1-9][0-9]*") {
		if ($2 == ">") {
			_start = int($3)+1
			_end = REV_MAX
		} else if ($2 == ">=") {
			_start = int($3)
			_end = REV_MAX
		} else if ($2 == "<" && int($3) > 0) {
			_start = 0
			_end = int($3)-1
		} else if ($2 == "<=") {
			_start = 0
			_end = int($3)-1
		} else {
			error("invalid revision descriptor")
		}
	} else if ($2 ~ "[1-9][0-9]*") {
		_start = int($2)
		_end = int($2)
	} else {
		error("invalid revision descriptor")
	}

	return (revrange_new(_start, _end))
}

# 
# Parse a variable group block starting at the current line
#
# group "Group Name" {
# 	u8	var_name[10] {
#		...
#	}
#	...
# }
#
function parse_variable_group(_ctx, _groups, _group, _group_name) {
	_ctx = parser_state_get_context(NVRAM)

	# Seek to the start of the name string
	shiftf(1)

	# Parse the first line
	_group_name = stringconstant_parse_line($0)

	# Incrementally parse line continuations
	while (get(_group_name, p_continued)) {
		getline
		stringconstant_append_line(_group_name, $0)
	}

	debug("group \"" get(_group_name, p_value) "\" {")

	# Register the new variable group
	_groups = get(_ctx, p_var_groups)
	_group = var_group_new(_group_name)
	array_append(_groups, _group)

	# Push our variable group block
	parser_state_open_block(_group)
}


#
# Parse a variable definition block starting at the current line
#
# u8	var_name[10] {
#	all1	ignore
#	desc	...
# }
#
function parse_variable_defn(_ctx, _vaccess, _type, _name, _fmt, _var,
    _var_list)
{
	_ctx = parser_state_get_context(SymbolContext)

	# Check for access modifier
	if ($1 == "private") {
		_vaccess = VAccessPrivate
		shiftf(1)
	} else if ($1 == "internal") {
		_vaccess = VAccessInternal
		shiftf(1)
	} else {
		_vaccess = VAccessPublic
	}

	# Find the base type
	if ((_type = type_named($1)) == null)
		error("unknown type '" $1 "'")

	# Parse (and trim) any array specifier from the variable name
	_name = $2
	_type = parse_array_type_specifier(_name, _type)
	sub(ARRAY_REGEX"$", "", _name)

	# Look for an existing variable definition
	if (_name in _g_var_names) {
		error("variable identifier '" _name "' previously defined at " \
		    "line " get(_g_var_names[_name], p_line))
	}

	# Construct new variable instance
	_var = var_new(_vaccess, _name, _type)
	debug((_private ? "private " : "") type_to_string(_type) " " _name " {")

	# Register in global name table
	_g_var_names[_name] = _var

	# Add to our parent context
	_var_list = get(_ctx, p_vars)
	array_append(_var_list, _var)

	# Push our variable definition block
	parser_state_open_block(_var)
}


#
# Return a string containing the human-readable list of valid Fmt names
#
function fmt_get_human_readable_list(_result, _fmts, _fmt, _nfmts, _i)
{
	# Build up a string listing the valid formats
	_fmts = map_to_array(ValueFormats)
	_result = ""

	_nfmts = array_size(_fmts)
	for (_i = 0; _i < _nfmts; _i++) {
		_fmt = array_get(_fmts, _i)
		if (_i+1 == _nfmts)
			_result = _result "or "

		_result = _name_str \
		    "'" get(_fmt, p_name) "'"

		if (_i+1 < _nfmts)
			_result = _result ", "
	}

	obj_delete(_fmts)
	return (_result)
}

#
# Parse a variable parameter from the current line
#
# fmt	(decimal|hex|macaddr|...)
# all1	ignore
# desc	"quoted string"
# help	"quoted string"
#
function parse_variable_param(param_name, _var, _vprops, _prop_id, _pval) {
	_var = parser_state_get_context(Var)

	if (param_name == "fmt") {
		debug($1 " " $2)

		# Check for an existing definition
		if ((_pval = get(_var, p_fmt)) != null) {
			error("fmt previously specified on line " \
			    obj_get_prop_nr(_var, p_fmt))
		}

		# Validate arguments
		if (NF != 2) {
			error("'" $1 "' requires a single parameter value of " \
			    fmt_get_human_readable_list())
		}

		if ((_pval = fmt_named($2)) == null) {
			error("'" $1 "' value '" $2 "' unrecognized. Must be " \
			    "one of " fmt_get_human_readable_list())
		}

		# Set fmt reference
		set(_var, p_fmt, _pval)
	} else if (param_name == "all1") {
		debug($1 " " $2)
		
		# Check for an existing definition
		if ((_pval = get(_var, p_ignall1)) != null) {
			error("all1 previously specified on line " \
			    obj_get_prop_nr(_var, p_ignall1))
		}

		# Check argument
		if (NF != 2)
			error("'" $1 "'requires a single 'ignore' argument")
		else if ($2 != "ignore")
			error("unknown "$1" value '"$2"', expected 'ignore'")

		# Set variable property
		set(_var, p_ignall1, 1)
	} else if (param_name == "desc" || param_name == "help") {
		# Fetch an indirect property reference for either the 'desc'
		# or 'help' property
		_prop_id = obj_get_named_prop_id(_var, param_name)

		# Check for an existing definition
		if ((_pval = prop_get(_var, _prop_id)) != null) {
			error(get(_var, p_name) " '" $1 "' redefined " \
			    "(previously defined on line " \
			    obj_get_prop_id_nr(_var, _prop_id) ")")
		}

		# Seek to the start of the desc/help string
		shiftf(1)

		# Parse the first line
		_pval = stringconstant_parse_line($0)

		# Incrementally parse line continuations
		while (get(_pval, p_continued)) {
			getline
			stringconstant_append_line(_pval, $0)
		}

		debug(param_name " \"" get(_pval, p_value) "\"")

		# Add to the var object
		prop_set(_var, _prop_id, _pval)
	} else {
		error("unknown variable property type: '" param_name "'")
	}
}


#
# Parse a top-level SROM layout block starting at the current line
#
# srom 4-7 {
#     0x000: ...
# }
#
function parse_srom_layout(_nvram, _srom_layouts, _revs, _layout) {
	_nvram = parser_state_get_context(NVRAM)
	_srom_layouts = get(_nvram, p_srom_layouts)

	# Parse revision descriptor and register SROM
	# instance
	_revs = parse_revrange()
	_layout = srom_layout_new(_revs)
	nvram_add_srom_layout(_nvram, _layout)

	debug("srom " revrange_to_string(_revs) " {")

	# Push new SROM parser state
	parser_state_open_block(_layout)
}


#
# Parse a nested srom range filter block starting at the current line
# srom 4-7 {
#	# Filter block
# 	srom 5 {
#		0x000: ...
#	}
# }
#
function parse_srom_layout_filter(_parent, _revs, _filter) {
	_parent = parser_state_get_context(SromLayout)

	# Parse revision descriptor
	_revs = parse_revrange()

	# Construct the filter (which also validates the revision range)
	_filter = srom_layout_filter_new(_parent, _revs)

	debug("srom " revrange_to_string(_revs) " {")

	# Push new SROM parser state
	parser_state_open_block(_filter)	
}


#
# Parse a SROM offset segment's attribute list from the current line
#
# <empty line>
# (&0xF0, >>4, =0x5340)
# ()
#
# Attribute designators:
#	&0xF	Mask value with 0xF
#	<<4	Shift left 4 bits
#	>>4	Shift right 4 bits
#	=0x53	The parsed value must be equal to this constant value
#
# May be followed by a | indicating that this segment should be OR'd with the
# segment that follows, or a terminating , indicating that a new offset's
# list of segments may follow.
#
function parse_srom_segment_attributes(offset, type, _attrs, _num_attr, _attr,
    _mask, _shift, _value, _i)
{
	# seek to offset (attributes...) or end of the offset expr (|,)
	sub("^[^,(|){}]+", "", $0)

	# defaults
	_mask = type_get_default_mask(type)
	_shift = 0

	# parse attributes
	if ($1 ~ "^\\(") {
		# extract attribute list
		if (match($0, /\([^|\(\)]*\)/) <= 0)
			error("expected attribute list")

		_attrs = substr($0, RSTART+1, RLENGTH-2)

		# drop attribute list from the input line
		$0 = substr($0, RSTART+RLENGTH, length($0) - RSTART+RLENGTH)

		# parse attributes
		_num_attr = split(_attrs, _g_attrs, ",[ \t]*")
		for (_i = 1; _i <= _num_attr; _i++) {
			_attr = _g_attrs[_i]
	
			if (sub("^&[ \t]*", "", _attr) > 0) {
				_mask = parse_uint_string(_attr)
			} else if (sub("^<<[ \t]*", "", _attr) > 0) {
				_shift = - parse_uint_string(_attr)
			} else if (sub("^>>[ \t]*", "", _attr) > 0) {
				_shift = parse_uint_string(_attr)
			} else if (sub("^=[ \t]*", "", _attr) > 0) {
				_value = _attr
			} else {
				error("unknown attribute '" _attr "'")
			}
		}
	}

	return (srom_segment_new(offset, type, _mask, _shift, _value))
}

#
# Parse a SROM offset's segment declaration from the current line
#
# +0x0:	u8 (&0xF0, >>4)		# read 8 bits at +0x0 (relative to srom entry
#				# offset, apply 0xF0 mask, shift >> 4
# 0x10:	u8 (&0xF0, >>4)		# identical to above, but perform the read at
#				# absolute offset 0x10
#
# +0x0: u8			# no attributes
# 0x10: u8
#
# +0x0				# simplified forms denoted by lack of ':'; the
# 0x0				# type is inherited from the parent SromEntry
#
#
function parse_srom_segment(base_offset, base_type, _simple, _type, _type_str,
    _offset, _attrs, _num_attr, _attr, _mask, _shift, _off_desc)
{
	# Fetch the offset value
	_offset = $1

	# Offset string must be one of:
	# 	simplified entry: <offset|+reloff>
	#		Provides only the offset, with the type inherited
	#		from the original variable definition
	#	standard entry: <offset|+reloff>:
	#		Provides the offset, followed by a type
	#
	# We differentiate the two by looking for (and simultaneously removing)
	# the trailing ':'
	if (!sub(/:$/, "", _offset))
		_simple = 1

	# The offset may either be absolute (e.g. 0x180) or relative (e.g.
	# +0x01).
	#
	# If we find a relative offset definition, we must trim the leading '+'
	# and then add the base offset
	if (sub(/^\+/, "", _offset)) {
		_offset = base_offset + parse_uint_offset(_offset)
	} else {
		
		_offset = parse_uint_offset(_offset)
	}

	# If simplified form, use the base type of the SROM entry. Otherwise,
	# we need to parse the type.
	if (_simple) {
		_type = base_type
	} else {
		_type_str = $2
		sub(/,$/, "", _type_str) # trim trailing ',', if any

		if ((_type = parse_type_string(_type_str)) == null)
			error("unknown type '" _type_str "'")
	}

	# Parse the trailing (... attributes ...), if any
	return (parse_srom_segment_attributes(_offset, _type))
}

#
# Parse a SROM variable entry from the current line
# <offset>: <type> <varname><array spec> ...
#
function parse_srom_variable_entry(_srom, _srom_revs, _rev_start, _rev_end,
    _srom_entries, _srom_revmap, _prev_entry, _ctx, _base_offset, _name,
    _stype, _var, _entry, _offset, _seg, _i)
{
	# Fetch our parent context
	_ctx = parser_state_get_context(SromContext)
	_srom_revs = get(_ctx, p_revisions)
	_rev_start = get(_srom_revs, p_start)
	_rev_end = get(_srom_revs, p_end)

	# Locate our enclosing layout
	_srom = parser_state_find_context(SromLayout)
	_srom_entries = get(_srom, p_entries)
	_srom_revmap = get(_srom, p_revmap)

	# Verify argument count
	if (NF < 3) {
		error("unrecognized srom entry syntax; must specify at " \
		    "least \"<offset>: <type> <variable name>\"")
	}

	# Parse the base offset
	_base_offset = parse_uint_offset($1)

	# Parse the base type
	if ((_stype = type_named($2)) == null)
		error("unknown type '" $2 "'")

	# Parse (and trim) any array specifier from the variable name
	_name = $3
	_stype = parse_array_type_specifier(_name, _stype)
	sub(ARRAY_REGEX"$", "", _name)

	# Locate the variable definition
	if (!(_name in _g_var_names))
		error("no definition found for variable '" _name "'")
	_var = _g_var_names[_name]

	# The SROM entry type must be a subtype of the variable's declared
	# type
	if (!type_can_represent(get(_var, p_type), _stype)) {
		error("'" type_to_string(_stype) "' SROM value cannot be " \
		    "coerced to '" type_to_string(get(_var, p_type)) " " _name \
		    "' variable")
	}

	# Create and register our new offset entry
	_entry = srom_entry_new(_var, _srom_revs, _base_offset, _stype)
	srom_layout_add_entry(_srom, _entry)

	# Seek to either the block start ('{'), or the attributes to be
	# used for a single offset/segment entry at `offset`
	shiftf(3)

	# Using the block syntax? */
	if ($1 == "{") {
		debug(sprintf("0x%03x: %s %s {", _base_offset,
		    type_to_string(_stype), _name))
		parser_state_open_block(_entry)
	} else {
		# Otherwise, we're using the simplified syntax -- create and
		# register our implicit SromOffset
		_offset = srom_offset_new()
		array_append(get(_entry, p_offsets), _offset)

		# Parse and register simplified segment syntax
		_seg = parse_srom_segment_attributes(_base_offset, _stype)
		array_append(get(_offset, p_segments), _seg)

		debug(sprintf("0x%03x: %s %s { %s }", _base_offset,
		    type_to_string(_stype), _name, segment_to_string(_seg)))
	}
}

#
# Parse all SromSegment entry segments readable starting at the current line
#
# <offset|+reloff>[,|]?
# <offset|+reloff>: <type>[,|]?
# <offset|+reloff>: <type> (<attributes>)[,|]?
#
function parse_srom_entry_segments(_entry, _base_off, _base_type, _offs,
    _offset, _segs, _seg, _more_seg, _more_vals)
{
	_entry = parser_state_get_context(SromEntry)
	_base_off = get(_entry, p_base_offset)
	_offs = get(_entry, p_offsets)

	_base_type = get(_entry, p_type)
	_base_type = type_get_base(_base_type)

	# Parse all offsets
	do {
		# Create a SromOffset
		_offset = srom_offset_new()
		_segs = get(_offset, p_segments)

		array_append(_offs, _offset)

		# Parse all segments
		do {
			_seg = parse_srom_segment(_base_off, _base_type)
			array_append(_segs, _seg)

			# Do more segments follow?
			_more_seg = ($1 == "|")
			if (_more_seg)
				shiftf(1, 1)

			if (_more_seg)
				debug(segment_to_string(_seg) " |")
			else
				debug(segment_to_string(_seg))
		} while (_more_seg)

		# Do more offsets follow?
		_more_vals = ($1 == ",")
		if (_more_vals)
			shiftf(1, 1)
	} while (_more_vals)
}