# Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
#
import re
import ConfigParser
from parameter import Parameter
from type import Type
# Opens and lexes the type spec file.
def getTypes(aTypefile):
# Add default types, looked up by 'size'
types = {'1' : Type('1', 'TUint8', '', 'TUint8', 1, 'AsTUint8', 'PutByte', 'PutTUint8', '', False, False, False, '0x0', '0xff', '', '', ''),
'2' : Type('2', 'TUint16', '', 'TUint16', 2, 'AsTUint16', 'PutBytes16', 'PutTUint16', '', False, False, False, '0x0', '0xffff', '', '', ''),
'3' : Type('3', 'TUint32', '', 'TUint32', 3, 'AsTUint32', 'PutBytes32', 'PutTUint32', '', False, False, False, '0x0', '0xffffff', '', '', ''),
'4' : Type('4', 'TUint32', '', 'TUint32', 4, 'AsTUint32', 'PutBytes32', 'PutTUint32', '', False, False, False, '0x0', '0xffffffff', '', '', ''),
'8' : Type('8', 'TUint64', '', 'TUint64', 8, 'AsTUint64', '', 'PutTUint64', '', False, False, False, '0x0', '0xffffffffffffffff', '', '', '')}
cfg = ConfigParser.ConfigParser()
cfg.read([aTypefile])
for s in cfg.sections():
t = Type(s,
cfg.get(s, 'Type'),
cfg.get(s, 'RetType'),
cfg.get(s, 'EventRetType'),
cfg.getint(s, 'Size'),
cfg.get(s, 'Getter'),
cfg.get(s, 'Setter'),
cfg.get(s, 'EventSetter'),
cfg.get(s, 'Maker'),
cfg.getboolean(s, 'PassByRef'),
cfg.getboolean(s, 'ReturnByRef'),
cfg.getboolean(s, 'EventReturnByRef'),
cfg.get(s, 'MinValue'),
cfg.get(s, 'MaxValue'),
cfg.get(s, 'CStringAvoider'),
cfg.get(s, 'PckgBufType'),
cfg.get(s, 'Cast'))
types[t.iName] = t
return types
def checked_regexop(op, regex, string):
if op is None or regex is None or string is None:
print "Invalid argument passed to checked_regexop";
sys.exit(0);
result = op(regex, string);
if result == None:
print "Regex operation '" + op.__name__ + "' returned None object"
print "with regex '" + regex + "'"
print "and string '" + string + "'"
import sys;
sys.exit(0);
return result;
# Retrieves one line from the command spec file.
# Uses a regexp to split the data.
def getLines(aLines):
if aLines == []:
return []
else:
m = checked_regexop(re.match, r'([0-9a-zA-Z_,\(\)]+):(,?)(.*)', aLines[0])
name = checked_regexop(re.match, r'([a-zA-Z_]+)', m.group(1))
# we would check_regexop for the extras, but if we don't have any arguments
# to pass then we will get a None back.... so we don't want to exit if
# the result is None.
# ext = checked_regexop(re.search, r'(\([0-9a-zA-Z_,]+\))', m.group(1))
ext = re.search(r'(\([0-9a-zA-Z_,]+\))', m.group(1))
name = name.group(1)
if ext == None:
ext = ""
else:
ext = ext.group(1)[1:-1]
m = checked_regexop(re.split, r'[^a-zA-Z_0-9@\*]+', m.group(3))
m = filter(lambda (v): len(v) != 0,
map(lambda (v): v.strip(), m))
return [(name, ext, m)] + getLines(aLines[1:])
# Retrieves all entries from the command spec file, ignoring lines starting with a #.
def getEntries(aFile):
return getLines(filter(lambda(e): e[0] != '#', file(aFile).readlines()))
# Calculates the size of all parameters used by a command.
def calcArrayBlockSize(aParams):
blockSize = 0
for p in aParams:
if p.iArray != '':
blockSize += p.iType.iSize
for p in aParams:
p.iBlockSize = blockSize
# Retrieves a dictionary of the 'folded' entries from the command file.
# A folded entry is a list of parameters indexed in the dictionary by the command name.
def getFolded(aEntries, aTypes, aHeaderOffset):
folded = {}
for e in aEntries:
folded[e[0]] = (e[1], getParameters(e[2], aTypes, aHeaderOffset))
calcArrayBlockSize(folded[e[0]][1])
return folded
# Builds a list of parameters for a command
def getParameters(aParams, aTypes, aOffset):
if aParams == []:
return []
if aParams[0] in aTypes:
t = aTypes[aParams[0]]
elif aParams[0][0] == '@' and aParams[0][1:] in aTypes:
t = aTypes[aParams[0][1:]]
else: # Type not known, assume TDesC8
t = aTypes.get(aParams[1], Type(aParams[0], 'TDesC8', 'TPtrC8', 'TPtrC8', aParams[1], 'AsString', 'PutString', 'PutString', '', True, False, False, '_L8("\\x0")', '_L8("\\xff")', 'UnknownType_instance', '', ''))
newOffset = aOffset
if t.iSize != 'n': # Not of 'infinite' size
newOffset += int(t.iSize)
if len(aParams) > 2 and aParams[2] == '*': # Is 'array', delimited by other parameter.
return [Parameter(t, aParams[0], aOffset, aParams[3])] + getParameters(aParams[4:], aTypes, newOffset)
else:
return [Parameter(t, aParams[0], aOffset)] + getParameters(aParams[2:], aTypes, newOffset)