| #!/usr/bin/env python |
| # Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """ Parser for PPAPI IDL """ |
| |
| # |
| # IDL Parser |
| # |
| # The parser is uses the PLY yacc library to build a set of parsing rules based |
| # on WebIDL. |
| # |
| # WebIDL, and WebIDL grammar can be found at: |
| # http://dev.w3.org/2006/webapi/WebIDL/ |
| # PLY can be found at: |
| # http://www.dabeaz.com/ply/ |
| # |
| # The parser generates a tree by recursively matching sets of items against |
| # defined patterns. When a match is made, that set of items is reduced |
| # to a new item. The new item can provide a match for parent patterns. |
| # In this way an AST is built (reduced) depth first. |
| # |
| |
| # |
| # Disable check for line length and Member as Function due to how grammar rules |
| # are defined with PLY |
| # |
| # pylint: disable=R0201 |
| # pylint: disable=C0301 |
| |
| import os.path |
| import sys |
| import time |
| |
| from idl_lexer import IDLLexer |
| from idl_node import IDLAttribute, IDLNode |
| |
| # |
| # Try to load the ply module, if not, then assume it is in the third_party |
| # directory. |
| # |
| try: |
| # Disable lint check which fails to find the ply module. |
| # pylint: disable=F0401 |
| from ply import lex |
| from ply import yacc |
| except ImportError: |
| module_path, module_name = os.path.split(__file__) |
| third_party = os.path.join(module_path, os.par, os.par, 'third_party') |
| sys.path.append(third_party) |
| # pylint: disable=F0401 |
| from ply import lex |
| from ply import yacc |
| |
| # |
| # ERROR_REMAP |
| # |
| # Maps the standard error formula into a more friendly error message. |
| # |
| ERROR_REMAP = { |
| 'Unexpected ")" after "(".' : 'Empty argument list.', |
| 'Unexpected ")" after ",".' : 'Missing argument.', |
| 'Unexpected "}" after ",".' : 'Trailing comma in block.', |
| 'Unexpected "}" after "{".' : 'Unexpected empty block.', |
| 'Unexpected comment after "}".' : 'Unexpected trailing comment.', |
| 'Unexpected "{" after keyword "enum".' : 'Enum missing name.', |
| 'Unexpected "{" after keyword "struct".' : 'Struct missing name.', |
| 'Unexpected "{" after keyword "interface".' : 'Interface missing name.', |
| } |
| |
| |
| def Boolean(val): |
| """Convert to strict boolean type.""" |
| if val: |
| return True |
| return False |
| |
| |
| def ListFromConcat(*items): |
| """Generate list by concatenating inputs""" |
| itemsout = [] |
| for item in items: |
| if item is None: |
| continue |
| if type(item) is not type([]): |
| itemsout.append(item) |
| else: |
| itemsout.extend(item) |
| |
| return itemsout |
| |
| def ExpandProduction(p): |
| if type(p) == list: |
| return '[' + ', '.join([ExpandProduction(x) for x in p]) + ']' |
| if type(p) == IDLNode: |
| return 'Node:' + str(p) |
| if type(p) == IDLAttribute: |
| return 'Attr:' + str(p) |
| if type(p) == str: |
| return 'str:' + p |
| return '%s:%s' % (p.__class__.__name__, str(p)) |
| |
| # TokenTypeName |
| # |
| # Generate a string which has the type and value of the token. |
| # |
| def TokenTypeName(t): |
| if t.type == 'SYMBOL': |
| return 'symbol %s' % t.value |
| if t.type in ['HEX', 'INT', 'OCT', 'FLOAT']: |
| return 'value %s' % t.value |
| if t.type == 'string' : |
| return 'string "%s"' % t.value |
| if t.type == 'COMMENT' : |
| return 'comment' |
| if t.type == t.value: |
| return '"%s"' % t.value |
| if t.type == ',': |
| return 'Comma' |
| if t.type == 'identifier': |
| return 'identifier "%s"' % t.value |
| return 'keyword "%s"' % t.value |
| |
| |
| # |
| # IDL Parser |
| # |
| # The Parser inherits the from the Lexer to provide PLY with the tokenizing |
| # definitions. Parsing patterns are encoded as functions where p_<name> is |
| # is called any time a patern matching the function documentation is found. |
| # Paterns are expressed in the form of: |
| # """ <new item> : <item> .... |
| # | <item> ....""" |
| # |
| # Where new item is the result of a match against one or more sets of items |
| # separated by the "|". |
| # |
| # The function is called with an object 'p' where p[0] is the output object |
| # and p[n] is the set of inputs for positive values of 'n'. Len(p) can be |
| # used to distinguish between multiple item sets in the pattern. |
| # |
| # For more details on parsing refer to the PLY documentation at |
| # http://www.dabeaz.com/ply/ |
| # |
| # The parser is based on the WebIDL standard. See: |
| # http://www.w3.org/TR/WebIDL/#idl-grammar |
| # |
| # The various productions are annotated so that the WHOLE number greater than |
| # zero in the comment denotes the matching WebIDL grammar definition. |
| # |
| # Productions with a fractional component in the comment denote additions to |
| # the WebIDL spec, such as comments. |
| # |
| |
| |
| class IDLParser(object): |
| # |
| # We force all input files to start with two comments. The first comment is a |
| # Copyright notice followed by a file comment and finally by file level |
| # productions. |
| # |
| # [0] Insert a TOP definition for Copyright and Comments |
| def p_Top(self, p): |
| """Top : COMMENT COMMENT Definitions""" |
| Copyright = self.BuildComment('Copyright', p, 1) |
| Filedoc = self.BuildComment('Comment', p, 2) |
| p[0] = ListFromConcat(Copyright, Filedoc, p[3]) |
| |
| # [0.1] Add support for Multiple COMMENTS |
| def p_Comments(self, p): |
| """Comments : CommentsRest""" |
| if len(p) > 1: |
| p[0] = p[1] |
| |
| # [0.2] Produce a COMMENT and aggregate sibling comments |
| def p_CommentsRest(self, p): |
| """CommentsRest : COMMENT CommentsRest |
| | """ |
| if len(p) > 1: |
| p[0] = ListFromConcat(self.BuildComment('Comment', p, 1), p[2]) |
| |
| |
| # |
| #The parser is based on the WebIDL standard. See: |
| # http://www.w3.org/TR/WebIDL/#idl-grammar |
| # |
| # [1] |
| def p_Definitions(self, p): |
| """Definitions : ExtendedAttributeList Definition Definitions |
| | """ |
| if len(p) > 1: |
| p[2].AddChildren(p[1]) |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [2] Add INLINE definition |
| def p_Definition(self, p): |
| """Definition : CallbackOrInterface |
| | Partial |
| | Dictionary |
| | Exception |
| | Enum |
| | Typedef |
| | ImplementsStatement""" |
| p[0] = p[1] |
| |
| # [2.1] Error recovery for definition |
| def p_DefinitionError(self, p): |
| """Definition : error ';'""" |
| p[0] = self.BuildError(p, 'Definition') |
| |
| # [3] |
| def p_CallbackOrInterface(self, p): |
| """CallbackOrInterface : CALLBACK CallbackRestOrInterface |
| | Interface""" |
| if len(p) > 2: |
| p[0] = p[2] |
| else: |
| p[0] = p[1] |
| |
| # [4] |
| def p_CallbackRestOrInterface(self, p): |
| """CallbackRestOrInterface : CallbackRest |
| | Interface""" |
| p[0] = p[1] |
| |
| # [5] |
| def p_Interface(self, p): |
| """Interface : INTERFACE identifier Inheritance '{' InterfaceMembers '}' ';'""" |
| p[0] = self.BuildNamed('Interface', p, 2, ListFromConcat(p[3], p[5])) |
| |
| # [6] Error recovery for PARTIAL |
| def p_Partial(self, p): |
| """Partial : PARTIAL PartialDefinition""" |
| p[2].AddChildren(self.BuildTrue('Partial')) |
| p[0] = p[2] |
| |
| # [6.1] Error recovery for Enums |
| def p_PartialError(self, p): |
| """Partial : PARTIAL error""" |
| p[0] = self.BuildError(p, 'Partial') |
| |
| # [7] |
| def p_PartialDefinition(self, p): |
| """PartialDefinition : PartialDictionary |
| | PartialInterface""" |
| p[0] = p[1] |
| |
| # [8] |
| def p_PartialInterface(self, p): |
| """PartialInterface : INTERFACE identifier '{' InterfaceMembers '}' ';'""" |
| p[0] = self.BuildNamed('Interface', p, 2, p[4]) |
| |
| # [9] |
| def p_InterfaceMembers(self, p): |
| """InterfaceMembers : ExtendedAttributeList InterfaceMember InterfaceMembers |
| |""" |
| if len(p) > 1: |
| p[2].AddChildren(p[1]) |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [10] |
| def p_InterfaceMember(self, p): |
| """InterfaceMember : Const |
| | AttributeOrOperation""" |
| p[0] = p[1] |
| |
| # [11] |
| def p_Dictionary(self, p): |
| """Dictionary : DICTIONARY identifier Inheritance '{' DictionaryMembers '}' ';'""" |
| p[0] = self.BuildNamed('Dictionary', p, 2, ListFromConcat(p[3], p[5])) |
| |
| # [11.1] Error recovery for regular Dictionary |
| def p_DictionaryError(self, p): |
| """Dictionary : DICTIONARY error ';'""" |
| p[0] = self.BuildError(p, 'Dictionary') |
| |
| # [12] |
| def p_DictionaryMembers(self, p): |
| """DictionaryMembers : ExtendedAttributeList DictionaryMember DictionaryMembers |
| |""" |
| if len(p) > 1: |
| p[2].AddChildren(p[1]) |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [13] |
| def p_DictionaryMember(self, p): |
| """DictionaryMember : Type identifier Default ';'""" |
| p[0] = self.BuildNamed('Key', p, 2, ListFromConcat(p[1], p[3])) |
| |
| # [14] |
| def p_PartialDictionary(self, p): |
| """PartialDictionary : DICTIONARY identifier '{' DictionaryMembers '}' ';'""" |
| partial = self.BuildTrue('Partial') |
| p[0] = self.BuildNamed('Dictionary', p, 2, ListFromConcat(p[4], partial)) |
| |
| # [14.1] Error recovery for Partial Dictionary |
| def p_PartialDictionaryError(self, p): |
| """PartialDictionary : DICTIONARY error ';'""" |
| p[0] = self.BuildError(p, 'PartialDictionary') |
| |
| # [15] |
| def p_Default(self, p): |
| """Default : '=' DefaultValue |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildProduction('Default', p, 2, p[2]) |
| |
| # [16] |
| def p_DefaultValue(self, p): |
| """DefaultValue : ConstValue |
| | string""" |
| if type(p[1]) == str: |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'DOMString'), |
| self.BuildAttribute('NAME', p[1])) |
| else: |
| p[0] = p[1] |
| |
| # [17] |
| def p_Exception(self, p): |
| """Exception : EXCEPTION identifier Inheritance '{' ExceptionMembers '}' ';'""" |
| p[0] = self.BuildNamed('Exception', p, 2, ListFromConcat(p[3], p[5])) |
| |
| # [18] |
| def p_ExceptionMembers(self, p): |
| """ExceptionMembers : ExtendedAttributeList ExceptionMember ExceptionMembers |
| |""" |
| if len(p) > 1: |
| p[2].AddChildren(p[1]) |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [18.1] Error recovery for ExceptionMembers |
| def p_ExceptionMembersError(self, p): |
| """ExceptionMembers : error""" |
| p[0] = self.BuildError(p, 'ExceptionMembers') |
| |
| # [19] |
| def p_Inheritance(self, p): |
| """Inheritance : ':' identifier |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildNamed('Inherit', p, 2) |
| |
| # [20] |
| def p_Enum(self, p): |
| """Enum : ENUM identifier '{' EnumValueList '}' ';'""" |
| p[0] = self.BuildNamed('Enum', p, 2, p[4]) |
| |
| # [20.1] Error recovery for Enums |
| def p_EnumError(self, p): |
| """Enum : ENUM error ';'""" |
| p[0] = self.BuildError(p, 'Enum') |
| |
| # [21] |
| def p_EnumValueList(self, p): |
| """EnumValueList : ExtendedAttributeList string EnumValues""" |
| enum = self.BuildNamed('EnumItem', p, 2, p[1]) |
| p[0] = ListFromConcat(enum, p[3]) |
| |
| # [22] |
| def p_EnumValues(self, p): |
| """EnumValues : ',' ExtendedAttributeList string EnumValues |
| |""" |
| if len(p) > 1: |
| enum = self.BuildNamed('EnumItem', p, 3, p[2]) |
| p[0] = ListFromConcat(enum, p[4]) |
| |
| # [23] |
| def p_CallbackRest(self, p): |
| """CallbackRest : identifier '=' ReturnType '(' ArgumentList ')' ';'""" |
| arguments = self.BuildProduction('Arguments', p, 4, p[5]) |
| p[0] = self.BuildNamed('Callback', p, 1, ListFromConcat(p[3], arguments)) |
| |
| # [24] |
| def p_Typedef(self, p): |
| """Typedef : TYPEDEF ExtendedAttributeListNoComments Type identifier ';'""" |
| p[0] = self.BuildNamed('Typedef', p, 4, ListFromConcat(p[2], p[3])) |
| |
| # [24.1] Error recovery for Typedefs |
| def p_TypedefError(self, p): |
| """Typedef : TYPEDEF error ';'""" |
| p[0] = self.BuildError(p, 'Typedef') |
| |
| # [25] |
| def p_ImplementsStatement(self, p): |
| """ImplementsStatement : identifier IMPLEMENTS identifier ';'""" |
| name = self.BuildAttribute('REFERENCE', p[3]) |
| p[0] = self.BuildNamed('Implements', p, 1, name) |
| |
| # [26] |
| def p_Const(self, p): |
| """Const : CONST ConstType identifier '=' ConstValue ';'""" |
| value = self.BuildProduction('Value', p, 5, p[5]) |
| p[0] = self.BuildNamed('Const', p, 3, ListFromConcat(p[2], value)) |
| |
| # [27] |
| def p_ConstValue(self, p): |
| """ConstValue : BooleanLiteral |
| | FloatLiteral |
| | integer |
| | null""" |
| if type(p[1]) == str: |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'integer'), |
| self.BuildAttribute('NAME', p[1])) |
| else: |
| p[0] = p[1] |
| |
| # [27.1] Add definition for NULL |
| def p_null(self, p): |
| """null : NULL""" |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'NULL'), |
| self.BuildAttribute('NAME', 'NULL')) |
| |
| # [28] |
| def p_BooleanLiteral(self, p): |
| """BooleanLiteral : TRUE |
| | FALSE""" |
| value = self.BuildAttribute('VALUE', Boolean(p[1] == 'true')) |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'boolean'), value) |
| |
| # [29] |
| def p_FloatLiteral(self, p): |
| """FloatLiteral : float |
| | '-' INFINITY |
| | INFINITY |
| | NAN """ |
| if len(p) > 2: |
| val = '-Infinity' |
| else: |
| val = p[1] |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'float'), |
| self.BuildAttribute('VALUE', val)) |
| |
| # [30] |
| def p_AttributeOrOperation(self, p): |
| """AttributeOrOperation : STRINGIFIER StringifierAttributeOrOperation |
| | Attribute |
| | Operation""" |
| if len(p) > 2: |
| p[0] = p[2] |
| else: |
| p[0] = p[1] |
| |
| # [31] |
| def p_StringifierAttributeOrOperation(self, p): |
| """StringifierAttributeOrOperation : Attribute |
| | OperationRest |
| | ';'""" |
| if p[1] == ';': |
| p[0] = self.BuildAttribute('STRINGIFIER', Boolean(True)) |
| else: |
| p[0] = ListFromConcat(self.BuildAttribute('STRINGIFIER', p[1]), p[1]) |
| |
| # [32] |
| def p_Attribute(self, p): |
| """Attribute : Inherit ReadOnly ATTRIBUTE Type identifier ';'""" |
| p[0] = self.BuildNamed('Attribute', p, 5, |
| ListFromConcat(p[1], p[2], p[4])) |
| |
| # [33] |
| def p_Inherit(self, p): |
| """Inherit : INHERIT |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('INHERIT') |
| |
| # [34] |
| def p_ReadOnly(self, p): |
| """ReadOnly : READONLY |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('READONLY') |
| |
| # [35] |
| def p_Operation(self, p): |
| """Operation : Qualifiers OperationRest""" |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| |
| # [36] |
| def p_Qualifiers(self, p): |
| """Qualifiers : STATIC |
| | Specials""" |
| if p[1] == 'static': |
| p[0] = self.BuildTrue('STATIC') |
| else: |
| p[0] = p[1] |
| |
| # [37] |
| def p_Specials(self, p): |
| """Specials : Special Specials |
| | """ |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[1], p[2]) |
| |
| # [38] |
| def p_Special(self, p): |
| """Special : GETTER |
| | SETTER |
| | CREATOR |
| | DELETER |
| | LEGACYCALLER""" |
| p[0] = self.BuildTrue(p[1].upper()) |
| |
| |
| # [39] |
| def p_OperationRest(self, p): |
| """OperationRest : ReturnType OptionalIdentifier '(' ArgumentList ')' ';'""" |
| arguments = self.BuildProduction('Arguments', p, 3, p[4]) |
| p[0] = self.BuildNamed('Operation', p, 2, ListFromConcat(p[1], arguments)) |
| |
| # [40] |
| def p_OptionalIdentifier(self, p): |
| """OptionalIdentifier : identifier |
| |""" |
| if len(p) > 1: |
| p[0] = p[1] |
| else: |
| p[0] = '_unnamed_' |
| |
| # [41] |
| def p_ArgumentList(self, p): |
| """ArgumentList : Argument Arguments |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[1], p[2]) |
| |
| # [41.1] ArgumentList error recovery |
| def p_ArgumentListError(self, p): |
| """ArgumentList : error """ |
| p[0] = self.BuildError(p, 'ArgumentList') |
| |
| # [42] |
| def p_Arguments(self, p): |
| """Arguments : ',' Argument Arguments |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [43] |
| def p_Argument(self, p): |
| """Argument : ExtendedAttributeList OptionalOrRequiredArgument""" |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| |
| |
| # [44] |
| def p_OptionalOrRequiredArgument(self, p): |
| """OptionalOrRequiredArgument : OPTIONAL Type ArgumentName Default |
| | Type Ellipsis ArgumentName""" |
| if len(p) > 4: |
| arg = self.BuildNamed('Argument', p, 3, ListFromConcat(p[2], p[4])) |
| arg.AddChildren(self.BuildTrue('OPTIONAL')) |
| else: |
| arg = self.BuildNamed('Argument', p, 3, ListFromConcat(p[1], p[2])) |
| p[0] = arg |
| |
| # [45] |
| def p_ArgumentName(self, p): |
| """ArgumentName : ArgumentNameKeyword |
| | identifier""" |
| p[0] = p[1] |
| |
| # [46] |
| def p_Ellipsis(self, p): |
| """Ellipsis : ELLIPSIS |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildNamed('Argument', p, 1) |
| p[0].AddChildren(self.BuildTrue('ELLIPSIS')) |
| |
| # [47] |
| def p_ExceptionMember(self, p): |
| """ExceptionMember : Const |
| | ExceptionField""" |
| p[0] = p[1] |
| |
| # [48] |
| def p_ExceptionField(self, p): |
| """ExceptionField : Type identifier ';'""" |
| p[0] = self.BuildNamed('ExceptionField', p, 2, p[1]) |
| |
| # [48.1] Error recovery for ExceptionMembers |
| def p_ExceptionFieldError(self, p): |
| """ExceptionField : error""" |
| p[0] = self.BuildError(p, 'ExceptionField') |
| |
| # [49] No comment version for mid statement attributes. |
| def p_ExtendedAttributeListNoComments(self, p): |
| """ExtendedAttributeListNoComments : '[' ExtendedAttribute ExtendedAttributes ']' |
| | """ |
| if len(p) > 2: |
| items = ListFromConcat(p[2], p[3]) |
| p[0] = self.BuildProduction('ExtAttributes', p, 1, items) |
| |
| # [49.1] Add optional comment field for start of statements. |
| def p_ExtendedAttributeList(self, p): |
| """ExtendedAttributeList : Comments '[' ExtendedAttribute ExtendedAttributes ']' |
| | Comments """ |
| if len(p) > 2: |
| items = ListFromConcat(p[3], p[4]) |
| attribs = self.BuildProduction('ExtAttributes', p, 2, items) |
| p[0] = ListFromConcat(p[1], attribs) |
| else: |
| p[0] = p[1] |
| |
| # [50] |
| def p_ExtendedAttributes(self, p): |
| """ExtendedAttributes : ',' ExtendedAttribute ExtendedAttributes |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # We only support: |
| # [ identifier ] |
| # [ identifier = identifier ] |
| # [ identifier ( ArgumentList )] |
| # [ identifier = identifier ( ArgumentList )] |
| # [51] map directly to 74-77 |
| # [52-54, 56] are unsupported |
| def p_ExtendedAttribute(self, p): |
| """ExtendedAttribute : ExtendedAttributeNoArgs |
| | ExtendedAttributeArgList |
| | ExtendedAttributeIdent |
| | ExtendedAttributeNamedArgList""" |
| p[0] = p[1] |
| |
| # [55] |
| def p_ArgumentNameKeyword(self, p): |
| """ArgumentNameKeyword : ATTRIBUTE |
| | CALLBACK |
| | CONST |
| | CREATOR |
| | DELETER |
| | DICTIONARY |
| | ENUM |
| | EXCEPTION |
| | GETTER |
| | IMPLEMENTS |
| | INHERIT |
| | LEGACYCALLER |
| | PARTIAL |
| | SETTER |
| | STATIC |
| | STRINGIFIER |
| | TYPEDEF |
| | UNRESTRICTED""" |
| p[0] = p[1] |
| |
| # [57] |
| def p_Type(self, p): |
| """Type : SingleType |
| | UnionType TypeSuffix""" |
| if len(p) == 2: |
| p[0] = self.BuildProduction('Type', p, 1, p[1]) |
| else: |
| p[0] = self.BuildProduction('Type', p, 1, ListFromConcat(p[1], p[2])) |
| |
| # [58] |
| def p_SingleType(self, p): |
| """SingleType : NonAnyType |
| | ANY TypeSuffixStartingWithArray""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[0] = ListFromConcat(self.BuildProduction('Any', p, 1), p[2]) |
| |
| # [59] |
| def p_UnionType(self, p): |
| """UnionType : '(' UnionMemberType OR UnionMemberType UnionMemberTypes ')'""" |
| |
| # [60] |
| def p_UnionMemberType(self, p): |
| """UnionMemberType : NonAnyType |
| | UnionType TypeSuffix |
| | ANY '[' ']' TypeSuffix""" |
| # [61] |
| def p_UnionMemberTypes(self, p): |
| """UnionMemberTypes : OR UnionMemberType UnionMemberTypes |
| |""" |
| |
| # [62] Moved DATE, DOMSTRING, OBJECT to PrimitiveType |
| def p_NonAnyType(self, p): |
| """NonAnyType : PrimitiveType TypeSuffix |
| | identifier TypeSuffix |
| | SEQUENCE '<' Type '>' Null""" |
| if len(p) == 3: |
| if type(p[1]) == str: |
| typeref = self.BuildNamed('Typeref', p, 1) |
| else: |
| typeref = p[1] |
| p[0] = ListFromConcat(typeref, p[2]) |
| |
| if len(p) == 6: |
| p[0] = self.BuildProduction('Sequence', p, 1, ListFromConcat(p[3], p[5])) |
| |
| |
| # [63] |
| def p_ConstType(self, p): |
| """ConstType : PrimitiveType Null |
| | identifier Null""" |
| if type(p[1]) == str: |
| p[0] = self.BuildNamed('Typeref', p, 1, p[2]) |
| else: |
| p[1].AddChildren(p[2]) |
| p[0] = p[1] |
| |
| |
| # [64] |
| def p_PrimitiveType(self, p): |
| """PrimitiveType : UnsignedIntegerType |
| | UnrestrictedFloatType |
| | BOOLEAN |
| | BYTE |
| | OCTET |
| | DOMSTRING |
| | DATE |
| | OBJECT""" |
| if type(p[1]) == str: |
| p[0] = self.BuildNamed('PrimitiveType', p, 1) |
| else: |
| p[0] = p[1] |
| |
| |
| # [65] |
| def p_UnrestrictedFloatType(self, p): |
| """UnrestrictedFloatType : UNRESTRICTED FloatType |
| | FloatType""" |
| if len(p) == 2: |
| typeref = self.BuildNamed('PrimitiveType', p, 1) |
| else: |
| typeref = self.BuildNamed('PrimitiveType', p, 2) |
| typeref.AddChildren(self.BuildTrue('UNRESTRICTED')) |
| p[0] = typeref |
| |
| |
| # [66] |
| def p_FloatType(self, p): |
| """FloatType : FLOAT |
| | DOUBLE""" |
| p[0] = p[1] |
| |
| # [67] |
| def p_UnsignedIntegerType(self, p): |
| """UnsignedIntegerType : UNSIGNED IntegerType |
| | IntegerType""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[0] = 'unsigned ' + p[2] |
| |
| # [68] |
| def p_IntegerType(self, p): |
| """IntegerType : SHORT |
| | LONG OptionalLong""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[0] = p[1] + p[2] |
| |
| # [69] |
| def p_OptionalLong(self, p): |
| """OptionalLong : LONG |
| | """ |
| if len(p) > 1: |
| p[0] = ' ' + p[1] |
| else: |
| p[0] = '' |
| |
| |
| # [70] Add support for sized array |
| def p_TypeSuffix(self, p): |
| """TypeSuffix : '[' integer ']' TypeSuffix |
| | '[' ']' TypeSuffix |
| | '?' TypeSuffixStartingWithArray |
| | """ |
| if len(p) == 5: |
| p[0] = self.BuildNamed('Array', p, 2, p[4]) |
| |
| if len(p) == 4: |
| p[0] = self.BuildProduction('Array', p, 1, p[3]) |
| |
| if len(p) == 3: |
| p[0] = ListFromConcat(self.BuildTrue('NULLABLE'), p[2]) |
| |
| |
| # [71] |
| def p_TypeSuffixStartingWithArray(self, p): |
| """TypeSuffixStartingWithArray : '[' ']' TypeSuffix |
| | """ |
| if len(p) > 1: |
| p[0] = self.BuildProduction('Array', p, 0, p[3]) |
| |
| # [72] |
| def p_Null(self, p): |
| """Null : '?' |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('NULLABLE') |
| |
| # [73] |
| def p_ReturnType(self, p): |
| """ReturnType : Type |
| | VOID""" |
| if p[1] == 'void': |
| p[0] = self.BuildProduction('Type', p, 1) |
| p[0].AddChildren(self.BuildNamed('PrimitiveType', p, 1)) |
| else: |
| p[0] = p[1] |
| |
| # [74] |
| def p_ExtendedAttributeNoArgs(self, p): |
| """ExtendedAttributeNoArgs : identifier""" |
| p[0] = self.BuildNamed('ExtAttribute', p, 1) |
| |
| # [75] |
| def p_ExtendedAttributeArgList(self, p): |
| """ExtendedAttributeArgList : identifier '(' ArgumentList ')'""" |
| arguments = self.BuildProduction('Arguments', p, 2, p[3]) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, arguments) |
| |
| # [76] |
| def p_ExtendedAttributeIdent(self, p): |
| """ExtendedAttributeIdent : identifier '=' identifier""" |
| value = self.BuildAttribute('VALUE', p[3]) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, value) |
| |
| # [77] |
| def p_ExtendedAttributeNamedArgList(self, p): |
| """ExtendedAttributeNamedArgList : identifier '=' identifier '(' ArgumentList ')'""" |
| args = self.BuildProduction('Arguments', p, 4, p[5]) |
| value = self.BuildNamed('Call', p, 3, args) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, value) |
| |
| # |
| # Parser Errors |
| # |
| # p_error is called whenever the parser can not find a pattern match for |
| # a set of items from the current state. The p_error function defined here |
| # is triggered logging an error, and parsing recovery happens as the |
| # p_<type>_error functions defined above are called. This allows the parser |
| # to continue so as to capture more than one error per file. |
| # |
| def p_error(self, t): |
| if t: |
| lineno = t.lineno |
| pos = t.lexpos |
| prev = self.yaccobj.symstack[-1] |
| if type(prev) == lex.LexToken: |
| msg = "Unexpected %s after %s." % ( |
| TokenTypeName(t), TokenTypeName(prev)) |
| else: |
| msg = "Unexpected %s." % (t.value) |
| else: |
| last = self.LastToken() |
| lineno = last.lineno |
| pos = last.lexpos |
| msg = "Unexpected end of file after %s." % TokenTypeName(last) |
| self.yaccobj.restart() |
| |
| # Attempt to remap the error to a friendlier form |
| if msg in ERROR_REMAP: |
| msg = ERROR_REMAP[msg] |
| |
| self._last_error_msg = msg |
| self._last_error_lineno = lineno |
| self._last_error_pos = pos |
| |
| def Warn(self, node, msg): |
| sys.stdout.write(node.GetLogLine(msg)) |
| self.parse_warnings += 1 |
| |
| def LastToken(self): |
| return self.lexer.last |
| |
| def __init__(self, lexer, verbose=False, debug=False, mute_error=False): |
| self.lexer = lexer |
| self.tokens = lexer.KnownTokens() |
| self.yaccobj = yacc.yacc(module=self, tabmodule=None, debug=debug, |
| optimize=0, write_tables=0) |
| self.parse_debug = debug |
| self.verbose = verbose |
| self.mute_error = mute_error |
| self._parse_errors = 0 |
| self._parse_warnings = 0 |
| self._last_error_msg = None |
| self._last_error_lineno = 0 |
| self._last_error_pos = 0 |
| |
| |
| # |
| # BuildProduction |
| # |
| # Production is the set of items sent to a grammar rule resulting in a new |
| # item being returned. |
| # |
| # p - Is the Yacc production object containing the stack of items |
| # index - Index into the production of the name for the item being produced. |
| # cls - The type of item being producted |
| # childlist - The children of the new item |
| def BuildProduction(self, cls, p, index, childlist=None): |
| try: |
| if not childlist: |
| childlist = [] |
| |
| filename = self.lexer.Lexer().filename |
| lineno = p.lineno(index) |
| pos = p.lexpos(index) |
| out = IDLNode(cls, filename, lineno, pos, childlist) |
| return out |
| except: |
| print 'Exception while parsing:' |
| for num, item in enumerate(p): |
| print ' [%d] %s' % (num, ExpandProduction(item)) |
| if self.LastToken(): |
| print 'Last token: %s' % str(self.LastToken()) |
| raise |
| |
| def BuildNamed(self, cls, p, index, childlist=None): |
| childlist = ListFromConcat(childlist) |
| childlist.append(self.BuildAttribute('NAME', p[index])) |
| return self.BuildProduction(cls, p, index, childlist) |
| |
| def BuildComment(self, cls, p, index): |
| name = p[index] |
| |
| # Remove comment markers |
| lines = [] |
| if name[:2] == '//': |
| # For C++ style, remove any leading whitespace and the '//' marker from |
| # each line. |
| form = 'cc' |
| for line in name.split('\n'): |
| start = line.find('//') |
| lines.append(line[start+2:]) |
| else: |
| # For C style, remove ending '*/'' |
| form = 'c' |
| for line in name[:-2].split('\n'): |
| # Remove characters until start marker for this line '*' if found |
| # otherwise it should be blank. |
| offs = line.find('*') |
| if offs >= 0: |
| line = line[offs + 1:].rstrip() |
| else: |
| line = '' |
| lines.append(line) |
| name = '\n'.join(lines) |
| childlist = [self.BuildAttribute('NAME', name), |
| self.BuildAttribute('FORM', form)] |
| return self.BuildProduction(cls, p, index, childlist) |
| |
| # |
| # BuildError |
| # |
| # Build and Errror node as part of the recovery process. |
| # |
| # |
| def BuildError(self, p, prod): |
| self._parse_errors += 1 |
| name = self.BuildAttribute('NAME', self._last_error_msg) |
| line = self.BuildAttribute('LINE', self._last_error_lineno) |
| pos = self.BuildAttribute('POS', self._last_error_pos) |
| prod = self.BuildAttribute('PROD', prod) |
| |
| node = self.BuildProduction('Error', p, 1, |
| ListFromConcat(name, line, pos, prod)) |
| if not self.mute_error: |
| node.Error(self._last_error_msg) |
| |
| return node |
| |
| # |
| # BuildAttribute |
| # |
| # An ExtendedAttribute is a special production that results in a property |
| # which is applied to the adjacent item. Attributes have no children and |
| # instead represent key/value pairs. |
| # |
| def BuildAttribute(self, key, val): |
| return IDLAttribute(key, val) |
| |
| def BuildFalse(self, key): |
| return IDLAttribute(key, Boolean(False)) |
| |
| def BuildTrue(self, key): |
| return IDLAttribute(key, Boolean(True)) |
| |
| def GetErrors(self): |
| # Access lexer errors, despite being private |
| # pylint: disable=W0212 |
| return self._parse_errors + self.lexer._lex_errors |
| |
| # |
| # ParseData |
| # |
| # Attempts to parse the current data loaded in the lexer. |
| # |
| def ParseText(self, filename, data): |
| self._parse_errors = 0 |
| self._parse_warnings = 0 |
| self._last_error_msg = None |
| self._last_error_lineno = 0 |
| self._last_error_pos = 0 |
| |
| try: |
| self.lexer.Tokenize(data, filename) |
| nodes = self.yaccobj.parse(lexer=self.lexer) or [] |
| name = self.BuildAttribute('NAME', filename) |
| return IDLNode('File', filename, 0, 0, nodes + [name]) |
| |
| except lex.LexError as lexError: |
| sys.stderr.write('Error in token: %s\n' % str(lexError)) |
| return None |
| |
| |
| |
| def ParseFile(parser, filename): |
| """Parse a file and return a File type of node.""" |
| with open(filename) as fileobject: |
| try: |
| out = parser.ParseText(filename, fileobject.read()) |
| out.SetProperty('DATETIME', time.ctime(os.path.getmtime(filename))) |
| out.SetProperty('ERRORS', parser.GetErrors()) |
| return out |
| |
| except Exception as e: |
| last = parser.LastToken() |
| sys.stderr.write('%s(%d) : Internal parsing error\n\t%s.\n' % ( |
| filename, last.lineno, str(e))) |
| |
| |
| def main(argv): |
| nodes = [] |
| parser = IDLParser(IDLLexer()) |
| errors = 0 |
| for filename in argv: |
| filenode = ParseFile(parser, filename) |
| if (filenode): |
| errors += filenode.GetProperty('ERRORS') |
| nodes.append(filenode) |
| |
| ast = IDLNode('AST', '__AST__', 0, 0, nodes) |
| |
| print '\n'.join(ast.Tree(accept_props=['PROD'])) |
| if errors: |
| print '\nFound %d errors.\n' % errors |
| |
| return errors |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main(sys.argv[1:])) |
