[qemu.git] / scripts / acpi_extract.py

#!/usr/bin/python
# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <[email protected]>
#
# 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');
Commit	Line	Data
74523b85 MT	1	#!/usr/bin/python
	2	# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <[email protected]>
	3	#
	4	# This program is free software; you can redistribute it and/or modify
	5	# it under the terms of the GNU General Public License as published by
	6	# the Free Software Foundation; either version 2 of the License, or
	7	# (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License along
	15	# with this program; if not, see <http://www.gnu.org/licenses/>.
	16
	17	# Process mixed ASL/AML listing (.lst file) produced by iasl -l
	18	# Locate and execute ACPI_EXTRACT directives, output offset info
	19	#
	20	# Documentation of ACPI_EXTRACT_* directive tags:
	21	#
	22	# These directive tags output offset information from AML for BIOS runtime
	23	# table generation.
	24	# Each directive is of the form:
	25	# ACPI_EXTRACT_<TYPE> <array_name> <Operator> (...)
	26	# and causes the extractor to create an array
	27	# named <array_name> with offset, in the generated AML,
	28	# of an object of a given type in the following <Operator>.
	29	#
	30	# A directive must fit on a single code line.
	31	#
	32	# Object type in AML is verified, a mismatch causes a build failure.
	33	#
	34	# Directives and operators currently supported are:
	35	# ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name()
	36	# ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name()
	37	# ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name()
	38	# ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method()
	39	# ACPI_EXTRACT_NAME_STRING - extract a NameString from Name()
	40	# ACPI_EXTRACT_PROCESSOR_START - start of Processor() block
	41	# ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor()
	42	# ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1
	43	# ACPI_EXTRACT_PKG_START - start of Package block
	44	#
	45	# ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode
	46	#
	47	# ACPI_EXTRACT is not allowed anywhere else in code, except in comments.
	48
	49	import re;
	50	import sys;
	51	import fileinput;
	52
	53	aml = []
	54	asl = []
	55	output = {}
	56	debug = ""
	57
	58	class asl_line:
	59	line = None
	60	lineno = None
	61	aml_offset = None
	62
	63	def die(diag):
	64	sys.stderr.write("Error: %s; %s\n" % (diag, debug))
65	sys.exit(1)
66
67	#Store an ASL command, matching AML offset, and input line (for debugging)
68	def add_asl(lineno, line):
69	l = asl_line()
70	l.line = line
71	l.lineno = lineno
72	l.aml_offset = len(aml)
73	asl.append(l)
74
75	#Store an AML byte sequence
76	#Verify that offset output by iasl matches # of bytes so far
77	def add_aml(offset, line):
78	o = int(offset, 16);
79	# Sanity check: offset must match size of code so far
80	if (o != len(aml)):
81	die("Offset 0x%x != 0x%x" % (o, len(aml)))
82	# Strip any trailing dots and ASCII dump after "
83	line = re.sub(r'\s\.\s".$',"", line)
84	# Strip traling whitespace
85	line = re.sub(r'\s+$',"", line)
86	# Strip leading whitespace
87	line = re.sub(r'^\s+',"", line)
88	# Split on whitespace
89	code = re.split(r'\s+', line)
90	for c in code:
91	# Require a legal hex number, two digits
92	if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))):
93	die("Unexpected octet %s" % c);
94	aml.append(int(c, 16));
95
96	# Process aml bytecode array, decoding AML
97	def aml_pkglen_bytes(offset):
98	# PkgLength can be multibyte. Bits 8-7 give the # of extra bytes.
99	pkglenbytes = aml[offset] >> 6;
100	return pkglenbytes + 1
101
102	def aml_pkglen(offset):
103	pkgstart = offset
104	pkglenbytes = aml_pkglen_bytes(offset)
105	pkglen = aml[offset] & 0x3F
106	# If multibyte, first nibble only uses bits 0-3
107	if ((pkglenbytes > 1) and (pkglen & 0x30)):
108	die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" %
109	(pkglen, pkglen))
110	offset += 1
111	pkglenbytes -= 1
112	for i in range(pkglenbytes):
113	pkglen \|= aml[offset + i] << (i * 8 + 4)
114	if (len(aml) < pkgstart + pkglen):
115	die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" %
116	(pkglen, offset, len(aml)))
117	return pkglen
118
119	# Given method offset, find its NameString offset
120	def aml_method_string(offset):
121	#0x14 MethodOp PkgLength NameString MethodFlags TermList
122	if (aml[offset] != 0x14):
123	die( "Method offset 0x%x: expected 0x14 actual 0x%x" %
124	(offset, aml[offset]));
125	offset += 1;
126	pkglenbytes = aml_pkglen_bytes(offset)
127	offset += pkglenbytes;
128	return offset;
129
130	# Given name offset, find its NameString offset
131	def aml_name_string(offset):
132	#0x08 NameOp NameString DataRef
133	if (aml[offset] != 0x08):
134	die( "Name offset 0x%x: expected 0x08 actual 0x%x" %
135	(offset, aml[offset]));
136	offset += 1
137	# Block Name Modifier. Skip it.
138	if (aml[offset] == 0x5c or aml[offset] == 0x5e):
139	offset += 1
140	return offset;
141
1c87d68c GH	142	# Given data offset, find variable length byte buffer offset
	143	def aml_data_buffer(offset, length):
	144	#0x11 PkgLength BufferSize ByteList
	145	if (length > 63):
	146	die( "Name offset 0x%x: expected a one byte PkgLength (length<=63)" %
	147	(offset));
	148	expect = [0x11, length+3, 0x0A, length]
74523b85 MT	149	if (aml[offset:offset+4] != expect):
74523b85 MT	150	die( "Name offset 0x%x: expected %s actual %s" %
1c87d68c	151	(offset, expect, aml[offset:offset+4]))
74523b85 MT	152	return offset + len(expect)
	153
	154	# Given data offset, find dword const offset
	155	def aml_data_dword_const(offset):
	156	#0x08 NameOp NameString DataRef
	157	if (aml[offset] != 0x0C):
	158	die( "Name offset 0x%x: expected 0x0C actual 0x%x" %
	159	(offset, aml[offset]));
	160	return offset + 1;
	161
	162	# Given data offset, find word const offset
	163	def aml_data_word_const(offset):
	164	#0x08 NameOp NameString DataRef
	165	if (aml[offset] != 0x0B):
	166	die( "Name offset 0x%x: expected 0x0B actual 0x%x" %
	167	(offset, aml[offset]));
	168	return offset + 1;
	169
	170	# Given data offset, find byte const offset
	171	def aml_data_byte_const(offset):
	172	#0x08 NameOp NameString DataRef
	173	if (aml[offset] != 0x0A):
	174	die( "Name offset 0x%x: expected 0x0A actual 0x%x" %
	175	(offset, aml[offset]));
	176	return offset + 1;
	177
1c87d68c GH	178	# Find name'd buffer
	179	def aml_name_buffer(offset, length):
	180	return aml_data_buffer(aml_name_string(offset) + 4, length)
74523b85 MT	181
	182	# Given name offset, find dword const offset
	183	def aml_name_dword_const(offset):
	184	return aml_data_dword_const(aml_name_string(offset) + 4)
	185
	186	# Given name offset, find word const offset
	187	def aml_name_word_const(offset):
	188	return aml_data_word_const(aml_name_string(offset) + 4)
	189
	190	# Given name offset, find byte const offset
	191	def aml_name_byte_const(offset):
	192	return aml_data_byte_const(aml_name_string(offset) + 4)
	193
	194	def aml_device_start(offset):
	195	#0x5B 0x82 DeviceOp PkgLength NameString
	196	if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x82)):
	197	die( "Name offset 0x%x: expected 0x5B 0x82 actual 0x%x 0x%x" %
	198	(offset, aml[offset], aml[offset + 1]));
	199	return offset
	200
	201	def aml_device_string(offset):
	202	#0x5B 0x82 DeviceOp PkgLength NameString
	203	start = aml_device_start(offset)
	204	offset += 2
	205	pkglenbytes = aml_pkglen_bytes(offset)
	206	offset += pkglenbytes
	207	return offset
	208
	209	def aml_device_end(offset):
	210	start = aml_device_start(offset)
	211	offset += 2
	212	pkglenbytes = aml_pkglen_bytes(offset)
	213	pkglen = aml_pkglen(offset)
	214	return offset + pkglen
	215
	216	def aml_processor_start(offset):
	217	#0x5B 0x83 ProcessorOp PkgLength NameString ProcID
	218	if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)):
	219	die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" %
	220	(offset, aml[offset], aml[offset + 1]));
	221	return offset
	222
	223	def aml_processor_string(offset):
	224	#0x5B 0x83 ProcessorOp PkgLength NameString ProcID
	225	start = aml_processor_start(offset)
	226	offset += 2
	227	pkglenbytes = aml_pkglen_bytes(offset)
	228	offset += pkglenbytes
	229	return offset
	230
	231	def aml_processor_end(offset):
	232	start = aml_processor_start(offset)
	233	offset += 2
	234	pkglenbytes = aml_pkglen_bytes(offset)
	235	pkglen = aml_pkglen(offset)
	236	return offset + pkglen
	237
	238	def aml_package_start(offset):
	239	offset = aml_name_string(offset) + 4
	240	# 0x12 PkgLength NumElements PackageElementList
	241	if (aml[offset] != 0x12):
	242	die( "Name offset 0x%x: expected 0x12 actual 0x%x" %
	243	(offset, aml[offset]));
	244	offset += 1
245	return offset + aml_pkglen_bytes(offset) + 1
246
247	lineno = 0
248	for line in fileinput.input():
249	# Strip trailing newline
250	line = line.rstrip();
251	# line number and debug string to output in case of errors
252	lineno = lineno + 1
253	debug = "input line %d: %s" % (lineno, line)
254	#ASL listing: space, then line#, then ...., then code
255	pasl = re.compile('^\s+([0-9]+)(:\s\s\|\.\.\.\.)\s*')
256	m = pasl.search(line)
257	if (m):
258	add_asl(lineno, pasl.sub("", line));
259	# AML listing: offset in hex, then ...., then code
260	paml = re.compile('^([0-9A-Fa-f]+)(:\s\s\|\.\.\.\.)\s*')
261	m = paml.search(line)
262	if (m):
263	add_aml(m.group(1), paml.sub("", line))
264
265	# Now go over code
266	# Track AML offset of a previous non-empty ASL command
267	prev_aml_offset = -1
268	for i in range(len(asl)):
269	debug = "input line %d: %s" % (asl[i].lineno, asl[i].line)
270
271	l = asl[i].line
272
273	# skip if not an extract directive
274	a = len(re.findall(r'ACPI_EXTRACT', l))
275	if (not a):
276	# If not empty, store AML offset. Will be used for sanity checks
277	# IASL seems to put {}. at random places in the listing.
278	# Ignore any non-words for the purpose of this test.
279	m = re.search(r'\w+', l)
280	if (m):
281	prev_aml_offset = asl[i].aml_offset
282	continue
283
284	if (a > 1):
285	die("Expected at most one ACPI_EXTRACT per line, actual %d" % a)
286
287	mext = re.search(r'''
288	^\s* # leading whitespace
289	/\\s # start C comment
290	(ACPI_EXTRACT_\w+) # directive: group(1)
291	\s+ # whitspace separates directive from array name
292	(\w+) # array name: group(2)
293	\s\/ # end of C comment
294	\s*$ # trailing whitespace
295	''', l, re.VERBOSE)
296	if (not mext):
297	die("Stray ACPI_EXTRACT in input")
298
299	# previous command must have produced some AML,
300	# otherwise we are in a middle of a block
301	if (prev_aml_offset == asl[i].aml_offset):
302	die("ACPI_EXTRACT directive in the middle of a block")
303
304	directive = mext.group(1)
305	array = mext.group(2)
306	offset = asl[i].aml_offset
307
308	if (directive == "ACPI_EXTRACT_ALL_CODE"):
309	if array in output:
310	die("%s directive used more than once" % directive)
311	output[array] = aml
312	continue
313	if (directive == "ACPI_EXTRACT_NAME_BUFFER8"):
1c87d68c GH	314	offset = aml_name_buffer(offset, 8)
	315	elif (directive == "ACPI_EXTRACT_NAME_BUFFER16"):
	316	offset = aml_name_buffer(offset, 16)
74523b85 MT	317	elif (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"):
	318	offset = aml_name_dword_const(offset)
	319	elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"):
	320	offset = aml_name_word_const(offset)
	321	elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"):
	322	offset = aml_name_byte_const(offset)
	323	elif (directive == "ACPI_EXTRACT_NAME_STRING"):
	324	offset = aml_name_string(offset)
	325	elif (directive == "ACPI_EXTRACT_METHOD_STRING"):
	326	offset = aml_method_string(offset)
	327	elif (directive == "ACPI_EXTRACT_DEVICE_START"):
	328	offset = aml_device_start(offset)
	329	elif (directive == "ACPI_EXTRACT_DEVICE_STRING"):
	330	offset = aml_device_string(offset)
	331	elif (directive == "ACPI_EXTRACT_DEVICE_END"):
	332	offset = aml_device_end(offset)
	333	elif (directive == "ACPI_EXTRACT_PROCESSOR_START"):
	334	offset = aml_processor_start(offset)
	335	elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"):
	336	offset = aml_processor_string(offset)
	337	elif (directive == "ACPI_EXTRACT_PROCESSOR_END"):
	338	offset = aml_processor_end(offset)
	339	elif (directive == "ACPI_EXTRACT_PKG_START"):
	340	offset = aml_package_start(offset)
	341	else:
	342	die("Unsupported directive %s" % directive)
	343
	344	if array not in output:
	345	output[array] = []
	346	output[array].append(offset)
	347
	348	debug = "at end of file"
	349
	350	def get_value_type(maxvalue):
	351	#Use type large enough to fit the table
	352	if (maxvalue >= 0x10000):
	353	return "int"
	354	elif (maxvalue >= 0x100):
	355	return "short"
	356	else:
	357	return "char"
	358
	359	# Pretty print output
	360	for array in output.keys():
	361	otype = get_value_type(max(output[array]))
	362	odata = []
	363	for value in output[array]:
	364	odata.append("0x%x" % value)
	365	sys.stdout.write("static unsigned %s %s[] = {\n" % (otype, array))
	366	sys.stdout.write(",\n".join(odata))
	367	sys.stdout.write('\n};\n');