scripts/acpi_extract.py - qemu - Git at Google

 #!/usr/bin/python
 # Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <mst@redhat.com>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License along
 # with this program; if not, see <http://www.gnu.org/licenses/>.

 # Process mixed ASL/AML listing (.lst file) produced by iasl -l
 # Locate and execute ACPI_EXTRACT directives, output offset info
 #
 # Documentation of ACPI_EXTRACT_* directive tags:
 #
 # These directive tags output offset information from AML for BIOS runtime
 # table generation.
 # Each directive is of the form:
 # ACPI_EXTRACT_<TYPE> <array_name> <Operator> (...)
 # and causes the extractor to create an array
 # named <array_name> with offset, in the generated AML,
 # of an object of a given type in the following <Operator>.
 #
 # A directive must fit on a single code line.
 #
 # Object type in AML is verified, a mismatch causes a build failure.
 #
 # Directives and operators currently supported are:
 # ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name()
 # ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name()
 # ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name()
 # ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method()
 # ACPI_EXTRACT_NAME_STRING - extract a NameString from Name()
 # ACPI_EXTRACT_PROCESSOR_START - start of Processor() block
 # ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor()
 # ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1
 # ACPI_EXTRACT_PKG_START - start of Package block
 #
 # ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode
 #
 # ACPI_EXTRACT is not allowed anywhere else in code, except in comments.

 import re;
 import sys;
 import fileinput;

 aml = []
 asl = []
 output = {}
 debug = ""

 class asl_line:
     line = None
     lineno = None
     aml_offset = None

 def die(diag):
     sys.stderr.write("Error: %s; %s\n" % (diag, debug))
     sys.exit(1)

 #Store an ASL command, matching AML offset, and input line (for debugging)
 def add_asl(lineno, line):
     l = asl_line()
     l.line = line
     l.lineno = lineno
     l.aml_offset = len(aml)
     asl.append(l)

 #Store an AML byte sequence
 #Verify that offset output by iasl matches # of bytes so far
 def add_aml(offset, line):
     o = int(offset, 16);
     # Sanity check: offset must match size of code so far
     if (o != len(aml)):
         die("Offset 0x%x != 0x%x" % (o, len(aml)))
     # Strip any trailing dots and ASCII dump after "
     line = re.sub(r'\s*\.*\s*".*$',"", line)
     # Strip traling whitespace
     line = re.sub(r'\s+$',"", line)
     # Strip leading whitespace
     line = re.sub(r'^\s+',"", line)
     # Split on whitespace
     code = re.split(r'\s+', line)
     for c in code:
         # Require a legal hex number, two digits
         if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))):
             die("Unexpected octet %s" % c);
         aml.append(int(c, 16));

 # Process aml bytecode array, decoding AML
 def aml_pkglen_bytes(offset):
     # PkgLength can be multibyte. Bits 8-7 give the # of extra bytes.
     pkglenbytes = aml[offset] >> 6;
     return pkglenbytes + 1

 def aml_pkglen(offset):
     pkgstart = offset
     pkglenbytes = aml_pkglen_bytes(offset)
     pkglen = aml[offset] & 0x3F
     # If multibyte, first nibble only uses bits 0-3
     if ((pkglenbytes > 1) and (pkglen & 0x30)):
         die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" %
             (pkglen, pkglen))
     offset += 1
     pkglenbytes -= 1
     for i in range(pkglenbytes):
         pkglen |= aml[offset + i] << (i * 8 + 4)
     if (len(aml) < pkgstart + pkglen):
         die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" %
             (pkglen, offset, len(aml)))
     return pkglen

 # Given method offset, find its NameString offset
 def aml_method_string(offset):
     #0x14 MethodOp PkgLength NameString MethodFlags TermList
     if (aml[offset] != 0x14):
         die( "Method offset 0x%x: expected 0x14 actual 0x%x" %
              (offset, aml[offset]));
     offset += 1;
     pkglenbytes = aml_pkglen_bytes(offset)
     offset += pkglenbytes;
     return offset;

 # Given name offset, find its NameString offset
 def aml_name_string(offset):
     #0x08 NameOp NameString DataRef
     if (aml[offset] != 0x08):
         die( "Name offset 0x%x: expected 0x08 actual 0x%x" %
              (offset, aml[offset]));
     offset += 1
     # Block Name Modifier. Skip it.
     if (aml[offset] == 0x5c or aml[offset] == 0x5e):
         offset += 1
     return offset;

 # Given data offset, find variable length byte buffer offset
 def aml_data_buffer(offset, length):
     #0x11 PkgLength BufferSize ByteList
     if (length > 63):
         die( "Name offset 0x%x: expected a one byte PkgLength (length<=63)" %
              (offset));
     expect = [0x11, length+3, 0x0A, length]
     if (aml[offset:offset+4] != expect):
         die( "Name offset 0x%x: expected %s actual %s" %
              (offset, expect, aml[offset:offset+4]))
     return offset + len(expect)

 # Given data offset, find dword const offset
 def aml_data_dword_const(offset):
     #0x08 NameOp NameString DataRef
     if (aml[offset] != 0x0C):
         die( "Name offset 0x%x: expected 0x0C actual 0x%x" %
              (offset, aml[offset]));
     return offset + 1;

 # Given data offset, find word const offset
 def aml_data_word_const(offset):
     #0x08 NameOp NameString DataRef
     if (aml[offset] != 0x0B):
         die( "Name offset 0x%x: expected 0x0B actual 0x%x" %
              (offset, aml[offset]));
     return offset + 1;

 # Given data offset, find byte const offset
 def aml_data_byte_const(offset):
     #0x08 NameOp NameString DataRef
     if (aml[offset] != 0x0A):
         die( "Name offset 0x%x: expected 0x0A actual 0x%x" %
              (offset, aml[offset]));
     return offset + 1;

 # Find name'd buffer
 def aml_name_buffer(offset, length):
     return aml_data_buffer(aml_name_string(offset) + 4, length)

 # Given name offset, find dword const offset
 def aml_name_dword_const(offset):
     return aml_data_dword_const(aml_name_string(offset) + 4)

 # Given name offset, find word const offset
 def aml_name_word_const(offset):
     return aml_data_word_const(aml_name_string(offset) + 4)

 # Given name offset, find byte const offset
 def aml_name_byte_const(offset):
     return aml_data_byte_const(aml_name_string(offset) + 4)

 def aml_device_start(offset):
     #0x5B 0x82 DeviceOp PkgLength NameString
     if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x82)):
         die( "Name offset 0x%x: expected 0x5B 0x82 actual 0x%x 0x%x" %
              (offset, aml[offset], aml[offset + 1]));
     return offset

 def aml_device_string(offset):
     #0x5B 0x82 DeviceOp PkgLength NameString
     start = aml_device_start(offset)
     offset += 2
     pkglenbytes = aml_pkglen_bytes(offset)
     offset += pkglenbytes
     return offset

 def aml_device_end(offset):
     start = aml_device_start(offset)
     offset += 2
     pkglenbytes = aml_pkglen_bytes(offset)
     pkglen = aml_pkglen(offset)
     return offset + pkglen

 def aml_processor_start(offset):
     #0x5B 0x83 ProcessorOp PkgLength NameString ProcID
     if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)):
         die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" %
              (offset, aml[offset], aml[offset + 1]));
     return offset

 def aml_processor_string(offset):
     #0x5B 0x83 ProcessorOp PkgLength NameString ProcID
     start = aml_processor_start(offset)
     offset += 2
     pkglenbytes = aml_pkglen_bytes(offset)
     offset += pkglenbytes
     return offset

 def aml_processor_end(offset):
     start = aml_processor_start(offset)
     offset += 2
     pkglenbytes = aml_pkglen_bytes(offset)
     pkglen = aml_pkglen(offset)
     return offset + pkglen

 def aml_package_start(offset):
     offset = aml_name_string(offset) + 4
     # 0x12 PkgLength NumElements PackageElementList
     if (aml[offset] != 0x12):
         die( "Name offset 0x%x: expected 0x12 actual 0x%x" %
              (offset, aml[offset]));
     offset += 1
     return offset + aml_pkglen_bytes(offset) + 1

 lineno = 0
 for line in fileinput.input():
     # Strip trailing newline
     line = line.rstrip();
     # line number and debug string to output in case of errors
     lineno = lineno + 1
     debug = "input line %d: %s" % (lineno, line)
     #ASL listing: space, then line#, then ...., then code
     pasl = re.compile('^\s+([0-9]+)(:\s\s|\.\.\.\.)\s*')
     m = pasl.search(line)
     if (m):
         add_asl(lineno, pasl.sub("", line));
     # AML listing: offset in hex, then ...., then code
     paml = re.compile('^([0-9A-Fa-f]+)(:\s\s|\.\.\.\.)\s*')
     m = paml.search(line)
     if (m):
         add_aml(m.group(1), paml.sub("", line))

 # Now go over code
 # Track AML offset of a previous non-empty ASL command
 prev_aml_offset = -1
 for i in range(len(asl)):
     debug = "input line %d: %s" % (asl[i].lineno, asl[i].line)

     l = asl[i].line

     # skip if not an extract directive
     a = len(re.findall(r'ACPI_EXTRACT', l))
     if (not a):
         # If not empty, store AML offset. Will be used for sanity checks
         # IASL seems to put {}. at random places in the listing.
         # Ignore any non-words for the purpose of this test.
         m = re.search(r'\w+', l)
         if (m):
                 prev_aml_offset = asl[i].aml_offset
         continue

     if (a > 1):
         die("Expected at most one ACPI_EXTRACT per line, actual %d" % a)

     mext = re.search(r'''
                       ^\s* # leading whitespace
                       /\*\s* # start C comment
                       (ACPI_EXTRACT_\w+) # directive: group(1)
                       \s+ # whitspace separates directive from array name
                       (\w+) # array name: group(2)
                       \s*\*/ # end of C comment
                       \s*$ # trailing whitespace
                       ''', l, re.VERBOSE)
     if (not mext):
         die("Stray ACPI_EXTRACT in input")

     # previous command must have produced some AML,
     # otherwise we are in a middle of a block
     if (prev_aml_offset == asl[i].aml_offset):
         die("ACPI_EXTRACT directive in the middle of a block")

     directive = mext.group(1)
     array = mext.group(2)
     offset = asl[i].aml_offset

     if (directive == "ACPI_EXTRACT_ALL_CODE"):
         if array in output:
             die("%s directive used more than once" % directive)
         output[array] = aml
         continue
     if (directive == "ACPI_EXTRACT_NAME_BUFFER8"):
         offset = aml_name_buffer(offset, 8)
     elif (directive == "ACPI_EXTRACT_NAME_BUFFER16"):
         offset = aml_name_buffer(offset, 16)
     elif (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"):
         offset = aml_name_dword_const(offset)
     elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"):
         offset = aml_name_word_const(offset)
     elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"):
         offset = aml_name_byte_const(offset)
     elif (directive == "ACPI_EXTRACT_NAME_STRING"):
         offset = aml_name_string(offset)
     elif (directive == "ACPI_EXTRACT_METHOD_STRING"):
         offset = aml_method_string(offset)
     elif (directive == "ACPI_EXTRACT_DEVICE_START"):
         offset = aml_device_start(offset)
     elif (directive == "ACPI_EXTRACT_DEVICE_STRING"):
         offset = aml_device_string(offset)
     elif (directive == "ACPI_EXTRACT_DEVICE_END"):
         offset = aml_device_end(offset)
     elif (directive == "ACPI_EXTRACT_PROCESSOR_START"):
         offset = aml_processor_start(offset)
     elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"):
         offset = aml_processor_string(offset)
     elif (directive == "ACPI_EXTRACT_PROCESSOR_END"):
         offset = aml_processor_end(offset)
     elif (directive == "ACPI_EXTRACT_PKG_START"):
         offset = aml_package_start(offset)
     else:
         die("Unsupported directive %s" % directive)

     if array not in output:
         output[array] = []
     output[array].append(offset)

 debug = "at end of file"

 def get_value_type(maxvalue):
     #Use type large enough to fit the table
     if (maxvalue >= 0x10000):
             return "int"
     elif (maxvalue >= 0x100):
             return "short"
     else:
             return "char"

 # Pretty print output
 for array in output.keys():
     otype = get_value_type(max(output[array]))
     odata = []
     for value in output[array]:
         odata.append("0x%x" % value)
     sys.stdout.write("static unsigned %s %s[] = {\n" % (otype, array))
     sys.stdout.write(",\n".join(odata))
     sys.stdout.write('\n};\n');
	#!/usr/bin/python
	# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <mst@redhat.com>
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License along
	# with this program; if not, see <http://www.gnu.org/licenses/>.

	# Process mixed ASL/AML listing (.lst file) produced by iasl -l
	# Locate and execute ACPI_EXTRACT directives, output offset info
	#
	# Documentation of ACPI_EXTRACT_* directive tags:
	#
	# These directive tags output offset information from AML for BIOS runtime
	# table generation.
	# Each directive is of the form:
	# ACPI_EXTRACT_<TYPE> <array_name> <Operator> (...)
	# and causes the extractor to create an array
	# named <array_name> with offset, in the generated AML,
	# of an object of a given type in the following <Operator>.
	#
	# A directive must fit on a single code line.
	#
	# Object type in AML is verified, a mismatch causes a build failure.
	#
	# Directives and operators currently supported are:
	# ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name()
	# ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name()
	# ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name()
	# ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method()
	# ACPI_EXTRACT_NAME_STRING - extract a NameString from Name()
	# ACPI_EXTRACT_PROCESSOR_START - start of Processor() block
	# ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor()
	# ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1
	# ACPI_EXTRACT_PKG_START - start of Package block
	#
	# ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode
	#
	# ACPI_EXTRACT is not allowed anywhere else in code, except in comments.

	import re;
	import sys;
	import fileinput;

	aml = []
	asl = []
	output = {}
	debug = ""

	class asl_line:
	line = None
	lineno = None
	aml_offset = None

	def die(diag):
	sys.stderr.write("Error: %s; %s\n" % (diag, debug))
	sys.exit(1)

	#Store an ASL command, matching AML offset, and input line (for debugging)
	def add_asl(lineno, line):
	l = asl_line()
	l.line = line
	l.lineno = lineno
	l.aml_offset = len(aml)
	asl.append(l)

	#Store an AML byte sequence
	#Verify that offset output by iasl matches # of bytes so far
	def add_aml(offset, line):
	o = int(offset, 16);
	# Sanity check: offset must match size of code so far
	if (o != len(aml)):
	die("Offset 0x%x != 0x%x" % (o, len(aml)))
	# Strip any trailing dots and ASCII dump after "
	line = re.sub(r'\s\.\s".$',"", line)
	# Strip traling whitespace
	line = re.sub(r'\s+$',"", line)
	# Strip leading whitespace
	line = re.sub(r'^\s+',"", line)
	# Split on whitespace
	code = re.split(r'\s+', line)
	for c in code:
	# Require a legal hex number, two digits
	if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))):
	die("Unexpected octet %s" % c);
	aml.append(int(c, 16));

	# Process aml bytecode array, decoding AML
	def aml_pkglen_bytes(offset):
	# PkgLength can be multibyte. Bits 8-7 give the # of extra bytes.
	pkglenbytes = aml[offset] >> 6;
	return pkglenbytes + 1

	def aml_pkglen(offset):
	pkgstart = offset
	pkglenbytes = aml_pkglen_bytes(offset)
	pkglen = aml[offset] & 0x3F
	# If multibyte, first nibble only uses bits 0-3
	if ((pkglenbytes > 1) and (pkglen & 0x30)):
	die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" %
	(pkglen, pkglen))
	offset += 1
	pkglenbytes -= 1
	for i in range(pkglenbytes):
	pkglen \|= aml[offset + i] << (i * 8 + 4)
	if (len(aml) < pkgstart + pkglen):
	die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" %
	(pkglen, offset, len(aml)))
	return pkglen

	# Given method offset, find its NameString offset
	def aml_method_string(offset):
	#0x14 MethodOp PkgLength NameString MethodFlags TermList
	if (aml[offset] != 0x14):
	die( "Method offset 0x%x: expected 0x14 actual 0x%x" %
	(offset, aml[offset]));
	offset += 1;
	pkglenbytes = aml_pkglen_bytes(offset)
	offset += pkglenbytes;
	return offset;

	# Given name offset, find its NameString offset
	def aml_name_string(offset):
	#0x08 NameOp NameString DataRef
	if (aml[offset] != 0x08):
	die( "Name offset 0x%x: expected 0x08 actual 0x%x" %
	(offset, aml[offset]));
	offset += 1
	# Block Name Modifier. Skip it.
	if (aml[offset] == 0x5c or aml[offset] == 0x5e):
	offset += 1
	return offset;

	# Given data offset, find variable length byte buffer offset
	def aml_data_buffer(offset, length):
	#0x11 PkgLength BufferSize ByteList
	if (length > 63):
	die( "Name offset 0x%x: expected a one byte PkgLength (length<=63)" %
	(offset));
	expect = [0x11, length+3, 0x0A, length]
	if (aml[offset:offset+4] != expect):
	die( "Name offset 0x%x: expected %s actual %s" %
	(offset, expect, aml[offset:offset+4]))
	return offset + len(expect)

	# Given data offset, find dword const offset
	def aml_data_dword_const(offset):
	#0x08 NameOp NameString DataRef
	if (aml[offset] != 0x0C):
	die( "Name offset 0x%x: expected 0x0C actual 0x%x" %
	(offset, aml[offset]));
	return offset + 1;

	# Given data offset, find word const offset
	def aml_data_word_const(offset):
	#0x08 NameOp NameString DataRef
	if (aml[offset] != 0x0B):
	die( "Name offset 0x%x: expected 0x0B actual 0x%x" %
	(offset, aml[offset]));
	return offset + 1;

	# Given data offset, find byte const offset
	def aml_data_byte_const(offset):
	#0x08 NameOp NameString DataRef
	if (aml[offset] != 0x0A):
	die( "Name offset 0x%x: expected 0x0A actual 0x%x" %
	(offset, aml[offset]));
	return offset + 1;

	# Find name'd buffer
	def aml_name_buffer(offset, length):
	return aml_data_buffer(aml_name_string(offset) + 4, length)

	# Given name offset, find dword const offset
	def aml_name_dword_const(offset):
	return aml_data_dword_const(aml_name_string(offset) + 4)

	# Given name offset, find word const offset
	def aml_name_word_const(offset):
	return aml_data_word_const(aml_name_string(offset) + 4)

	# Given name offset, find byte const offset
	def aml_name_byte_const(offset):
	return aml_data_byte_const(aml_name_string(offset) + 4)

	def aml_device_start(offset):
	#0x5B 0x82 DeviceOp PkgLength NameString
	if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x82)):
	die( "Name offset 0x%x: expected 0x5B 0x82 actual 0x%x 0x%x" %
	(offset, aml[offset], aml[offset + 1]));
	return offset

	def aml_device_string(offset):
	#0x5B 0x82 DeviceOp PkgLength NameString
	start = aml_device_start(offset)
	offset += 2
	pkglenbytes = aml_pkglen_bytes(offset)
	offset += pkglenbytes
	return offset

	def aml_device_end(offset):
	start = aml_device_start(offset)
	offset += 2
	pkglenbytes = aml_pkglen_bytes(offset)
	pkglen = aml_pkglen(offset)
	return offset + pkglen

	def aml_processor_start(offset):
	#0x5B 0x83 ProcessorOp PkgLength NameString ProcID
	if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)):
	die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" %
	(offset, aml[offset], aml[offset + 1]));
	return offset

	def aml_processor_string(offset):
	#0x5B 0x83 ProcessorOp PkgLength NameString ProcID
	start = aml_processor_start(offset)
	offset += 2
	pkglenbytes = aml_pkglen_bytes(offset)
	offset += pkglenbytes
	return offset

	def aml_processor_end(offset):
	start = aml_processor_start(offset)
	offset += 2
	pkglenbytes = aml_pkglen_bytes(offset)
	pkglen = aml_pkglen(offset)
	return offset + pkglen

	def aml_package_start(offset):
	offset = aml_name_string(offset) + 4
	# 0x12 PkgLength NumElements PackageElementList
	if (aml[offset] != 0x12):
	die( "Name offset 0x%x: expected 0x12 actual 0x%x" %
	(offset, aml[offset]));
	offset += 1
	return offset + aml_pkglen_bytes(offset) + 1

	lineno = 0
	for line in fileinput.input():
	# Strip trailing newline
	line = line.rstrip();
	# line number and debug string to output in case of errors
	lineno = lineno + 1
	debug = "input line %d: %s" % (lineno, line)
	#ASL listing: space, then line#, then ...., then code
	pasl = re.compile('^\s+([0-9]+)(:\s\s\|\.\.\.\.)\s*')
	m = pasl.search(line)
	if (m):
	add_asl(lineno, pasl.sub("", line));
	# AML listing: offset in hex, then ...., then code
	paml = re.compile('^([0-9A-Fa-f]+)(:\s\s\|\.\.\.\.)\s*')
	m = paml.search(line)
	if (m):
	add_aml(m.group(1), paml.sub("", line))

	# Now go over code
	# Track AML offset of a previous non-empty ASL command
	prev_aml_offset = -1
	for i in range(len(asl)):
	debug = "input line %d: %s" % (asl[i].lineno, asl[i].line)

	l = asl[i].line

	# skip if not an extract directive
	a = len(re.findall(r'ACPI_EXTRACT', l))
	if (not a):
	# If not empty, store AML offset. Will be used for sanity checks
	# IASL seems to put {}. at random places in the listing.
	# Ignore any non-words for the purpose of this test.
	m = re.search(r'\w+', l)
	if (m):
	prev_aml_offset = asl[i].aml_offset
	continue

	if (a > 1):
	die("Expected at most one ACPI_EXTRACT per line, actual %d" % a)

	mext = re.search(r'''
	^\s* # leading whitespace
	/\\s # start C comment
	(ACPI_EXTRACT_\w+) # directive: group(1)
	\s+ # whitspace separates directive from array name
	(\w+) # array name: group(2)
	\s\/ # end of C comment
	\s*$ # trailing whitespace
	''', l, re.VERBOSE)
	if (not mext):
	die("Stray ACPI_EXTRACT in input")

	# previous command must have produced some AML,
	# otherwise we are in a middle of a block
	if (prev_aml_offset == asl[i].aml_offset):
	die("ACPI_EXTRACT directive in the middle of a block")

	directive = mext.group(1)
	array = mext.group(2)
	offset = asl[i].aml_offset

	if (directive == "ACPI_EXTRACT_ALL_CODE"):
	if array in output:
	die("%s directive used more than once" % directive)
	output[array] = aml
	continue
	if (directive == "ACPI_EXTRACT_NAME_BUFFER8"):
	offset = aml_name_buffer(offset, 8)
	elif (directive == "ACPI_EXTRACT_NAME_BUFFER16"):
	offset = aml_name_buffer(offset, 16)
	elif (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"):
	offset = aml_name_dword_const(offset)
	elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"):
	offset = aml_name_word_const(offset)
	elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"):
	offset = aml_name_byte_const(offset)
	elif (directive == "ACPI_EXTRACT_NAME_STRING"):
	offset = aml_name_string(offset)
	elif (directive == "ACPI_EXTRACT_METHOD_STRING"):
	offset = aml_method_string(offset)
	elif (directive == "ACPI_EXTRACT_DEVICE_START"):
	offset = aml_device_start(offset)
	elif (directive == "ACPI_EXTRACT_DEVICE_STRING"):
	offset = aml_device_string(offset)
	elif (directive == "ACPI_EXTRACT_DEVICE_END"):
	offset = aml_device_end(offset)
	elif (directive == "ACPI_EXTRACT_PROCESSOR_START"):
	offset = aml_processor_start(offset)
	elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"):
	offset = aml_processor_string(offset)
	elif (directive == "ACPI_EXTRACT_PROCESSOR_END"):
	offset = aml_processor_end(offset)
	elif (directive == "ACPI_EXTRACT_PKG_START"):
	offset = aml_package_start(offset)
	else:
	die("Unsupported directive %s" % directive)

	if array not in output:
	output[array] = []
	output[array].append(offset)

	debug = "at end of file"

	def get_value_type(maxvalue):
	#Use type large enough to fit the table
	if (maxvalue >= 0x10000):
	return "int"
	elif (maxvalue >= 0x100):
	return "short"
	else:
	return "char"

	# Pretty print output
	for array in output.keys():
	otype = get_value_type(max(output[array]))
	odata = []
	for value in output[array]:
	odata.append("0x%x" % value)
	sys.stdout.write("static unsigned %s %s[] = {\n" % (otype, array))
	sys.stdout.write(",\n".join(odata))
	sys.stdout.write('\n};\n');