| #!/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://heycam.github.io/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://heycam.github.io/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://heycam.github.io/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] |
| 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])) |
| |
| # [5.1] Error recovery for interface. |
| def p_InterfaceError(self, p): |
| """Interface : INTERFACE identifier Inheritance '{' error""" |
| p[0] = self.BuildError(p, 'Interface') |
| |
| # [6] |
| def p_Partial(self, p): |
| """Partial : PARTIAL PartialDefinition""" |
| p[2].AddChildren(self.BuildTrue('Partial')) |
| p[0] = p[2] |
| |
| # [6.1] Error recovery for Partial |
| 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]) |
| |
| # [9.1] Error recovery for InterfaceMembers |
| def p_InterfaceMembersError(self, p): |
| """InterfaceMembers : error""" |
| p[0] = self.BuildError(p, 'InterfaceMembers') |
| |
| # [10] Removed unsupported: Serializer |
| def p_InterfaceMember(self, p): |
| """InterfaceMember : Const |
| | Operation |
| | Serializer |
| | Stringifier |
| | StaticMember |
| | Iterable |
| | ReadonlyMember |
| | ReadWriteAttribute |
| | ReadWriteMaplike |
| | ReadWriteSetlike""" |
| 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') |
| |
| # [11.2] Error recovery for regular Dictionary |
| # (for errors inside dictionary definition) |
| def p_DictionaryError2(self, p): |
| """Dictionary : DICTIONARY identifier Inheritance '{' 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]) |
| |
| # [12.1] Error recovery for DictionaryMembers |
| def p_DictionaryMembersError(self, p): |
| """DictionaryMembers : ExtendedAttributeList error""" |
| p[0] = self.BuildError(p, 'DictionaryMembers') |
| |
| # [13] |
| def p_DictionaryMember(self, p): |
| """DictionaryMember : Required Type identifier Default ';'""" |
| p[0] = self.BuildNamed('Key', p, 3, ListFromConcat(p[1], p[2], p[4])) |
| |
| # [14] |
| def p_Required(self, p): |
| """Required : REQUIRED |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('REQUIRED') |
| |
| # [15] |
| def p_PartialDictionary(self, p): |
| """PartialDictionary : DICTIONARY identifier '{' DictionaryMembers '}' ';'""" |
| partial = self.BuildTrue('Partial') |
| p[0] = self.BuildNamed('Dictionary', p, 2, ListFromConcat(p[4], partial)) |
| |
| # [15.1] Error recovery for Partial Dictionary |
| def p_PartialDictionaryError(self, p): |
| """PartialDictionary : DICTIONARY error ';'""" |
| p[0] = self.BuildError(p, 'PartialDictionary') |
| |
| # [16] |
| def p_Default(self, p): |
| """Default : '=' DefaultValue |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildProduction('Default', p, 2, p[2]) |
| |
| # [17] |
| def p_DefaultValue(self, p): |
| """DefaultValue : ConstValue |
| | string |
| | '[' ']'""" |
| if len(p) == 3: |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'sequence'), |
| self.BuildAttribute('VALUE', '[]')) |
| elif type(p[1]) == str: |
| p[0] = ListFromConcat(self.BuildAttribute('TYPE', 'DOMString'), |
| self.BuildAttribute('NAME', p[1])) |
| else: |
| p[0] = p[1] |
| |
| # [] - Not specified |
| def p_Exception(self, p): |
| """Exception : EXCEPTION identifier Inheritance '{' ExceptionMembers '}' ';'""" |
| p[0] = self.BuildNamed('Exception', p, 2, ListFromConcat(p[3], p[5])) |
| |
| # [] - Not specified |
| 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]) |
| |
| # [.1] Error recovery for ExceptionMembers - Not specified |
| def p_ExceptionMembersError(self, p): |
| """ExceptionMembers : error""" |
| p[0] = self.BuildError(p, 'ExceptionMembers') |
| |
| # [18] |
| def p_Inheritance(self, p): |
| """Inheritance : ':' identifier |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildNamed('Inherit', p, 2) |
| |
| # [19] |
| def p_Enum(self, p): |
| """Enum : ENUM identifier '{' EnumValueList '}' ';'""" |
| p[0] = self.BuildNamed('Enum', p, 2, p[4]) |
| |
| # [19.1] Error recovery for Enums |
| def p_EnumError(self, p): |
| """Enum : ENUM error ';'""" |
| p[0] = self.BuildError(p, 'Enum') |
| |
| # [20] |
| def p_EnumValueList(self, p): |
| """EnumValueList : ExtendedAttributeList string EnumValueListComma""" |
| enum = self.BuildNamed('EnumItem', p, 2, p[1]) |
| p[0] = ListFromConcat(enum, p[3]) |
| |
| # [21] |
| def p_EnumValueListComma(self, p): |
| """EnumValueListComma : ',' EnumValueListString |
| |""" |
| if len(p) > 1: |
| p[0] = p[2] |
| |
| # [22] |
| def p_EnumValueListString(self, p): |
| """EnumValueListString : ExtendedAttributeList string EnumValueListComma |
| |""" |
| if len(p) > 1: |
| enum = self.BuildNamed('EnumItem', p, 2, p[1]) |
| p[0] = ListFromConcat(enum, p[3]) |
| |
| # [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_Serializer(self, p): |
| """Serializer : SERIALIZER SerializerRest""" |
| p[0] = self.BuildProduction('Serializer', p, 1, p[2]) |
| |
| # [31] |
| # TODO(jl): This adds ReturnType and ';', missing from the spec's grammar. |
| # https://www.w3.org/Bugs/Public/show_bug.cgi?id=20361 |
| def p_SerializerRest(self, p): |
| """SerializerRest : ReturnType OperationRest |
| | '=' SerializationPattern ';' |
| | ';'""" |
| if len(p) == 3: |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| elif len(p) == 4: |
| p[0] = p[2] |
| |
| # [32] |
| def p_SerializationPattern(self, p): |
| """SerializationPattern : '{' SerializationPatternMap '}' |
| | '[' SerializationPatternList ']' |
| | identifier""" |
| if len(p) > 2: |
| p[0] = p[2] |
| else: |
| p[0] = self.BuildAttribute('ATTRIBUTE', p[1]) |
| |
| # [33] |
| # TODO(jl): This adds the "ATTRIBUTE" and "INHERIT ',' ATTRIBUTE" variants, |
| # missing from the spec's grammar. |
| # https://www.w3.org/Bugs/Public/show_bug.cgi?id=20361 |
| def p_SerializationPatternMap(self, p): |
| """SerializationPatternMap : GETTER |
| | ATTRIBUTE |
| | INHERIT ',' ATTRIBUTE |
| | INHERIT Identifiers |
| | identifier Identifiers |
| |""" |
| p[0] = self.BuildProduction('Map', p, 0) |
| if len(p) == 4: |
| p[0].AddChildren(self.BuildTrue('INHERIT')) |
| p[0].AddChildren(self.BuildTrue('ATTRIBUTE')) |
| elif len(p) > 1: |
| if p[1] == 'getter': |
| p[0].AddChildren(self.BuildTrue('GETTER')) |
| elif p[1] == 'attribute': |
| p[0].AddChildren(self.BuildTrue('ATTRIBUTE')) |
| else: |
| if p[1] == 'inherit': |
| p[0].AddChildren(self.BuildTrue('INHERIT')) |
| attributes = p[2] |
| else: |
| attributes = ListFromConcat(p[1], p[2]) |
| p[0].AddChildren(self.BuildAttribute('ATTRIBUTES', attributes)) |
| |
| # [34] |
| def p_SerializationPatternList(self, p): |
| """SerializationPatternList : GETTER |
| | identifier Identifiers |
| |""" |
| p[0] = self.BuildProduction('List', p, 0) |
| if len(p) > 1: |
| if p[1] == 'getter': |
| p[0].AddChildren(self.BuildTrue('GETTER')) |
| else: |
| attributes = ListFromConcat(p[1], p[2]) |
| p[0].AddChildren(self.BuildAttribute('ATTRIBUTES', attributes)) |
| |
| # [35] |
| def p_Stringifier(self, p): |
| """Stringifier : STRINGIFIER StringifierRest""" |
| p[0] = self.BuildProduction('Stringifier', p, 1, p[2]) |
| |
| # [36] |
| def p_StringifierRest(self, p): |
| """StringifierRest : AttributeRest |
| | ReturnType OperationRest |
| | ';'""" |
| if len(p) == 3: |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| elif p[1] != ';': |
| p[0] = p[1] |
| |
| # [37] |
| def p_StaticMember(self, p): |
| """StaticMember : STATIC StaticMemberRest""" |
| p[2].AddChildren(self.BuildTrue('STATIC')) |
| p[0] = p[2] |
| |
| # [38] |
| def p_StaticMemberRest(self, p): |
| """StaticMemberRest : ReadOnly AttributeRest |
| | ReturnType OperationRest""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| |
| # [39] |
| def p_ReadonlyMember(self, p): |
| """ReadonlyMember : READONLY ReadonlyMemberRest""" |
| p[2].AddChildren(self.BuildTrue('READONLY')) |
| p[0] = p[2] |
| |
| # [40] |
| def p_ReadonlyMemberRest(self, p): |
| """ReadonlyMemberRest : AttributeRest |
| | MaplikeRest |
| | SetlikeRest""" |
| p[0] = p[1] |
| |
| # [41] |
| def p_ReadWriteAttribute(self, p): |
| """ReadWriteAttribute : INHERIT ReadOnly AttributeRest |
| | AttributeRest""" |
| if len(p) > 2: |
| inherit = self.BuildTrue('INHERIT') |
| p[3].AddChildren(ListFromConcat(inherit, p[2])) |
| p[0] = p[3] |
| else: |
| p[0] = p[1] |
| |
| # [42] |
| def p_AttributeRest(self, p): |
| """AttributeRest : ATTRIBUTE Type AttributeName ';'""" |
| p[0] = self.BuildNamed('Attribute', p, 3, p[2]) |
| |
| # [43] |
| def p_AttributeName(self, p): |
| """AttributeName : AttributeNameKeyword |
| | identifier""" |
| p[0] = p[1] |
| |
| # [44] |
| def p_AttributeNameKeyword(self, p): |
| """AttributeNameKeyword : REQUIRED""" |
| p[0] = p[1] |
| |
| # [45] Unreferenced in the specification |
| |
| # [46] |
| def p_ReadOnly(self, p): |
| """ReadOnly : READONLY |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('READONLY') |
| |
| # [47] |
| def p_Operation(self, p): |
| """Operation : ReturnType OperationRest |
| | SpecialOperation""" |
| if len(p) == 3: |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| else: |
| p[0] = p[1] |
| |
| # [48] |
| def p_SpecialOperation(self, p): |
| """SpecialOperation : Special Specials ReturnType OperationRest""" |
| p[4].AddChildren(ListFromConcat(p[1], p[2], p[3])) |
| p[0] = p[4] |
| |
| # [49] |
| def p_Specials(self, p): |
| """Specials : Special Specials |
| | """ |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[1], p[2]) |
| |
| # [50] |
| def p_Special(self, p): |
| """Special : GETTER |
| | SETTER |
| | CREATOR |
| | DELETER |
| | LEGACYCALLER""" |
| p[0] = self.BuildTrue(p[1].upper()) |
| |
| # [51] |
| def p_OperationRest(self, p): |
| """OperationRest : OptionalIdentifier '(' ArgumentList ')' ';'""" |
| arguments = self.BuildProduction('Arguments', p, 2, p[3]) |
| p[0] = self.BuildNamed('Operation', p, 1, arguments) |
| |
| # [52] |
| def p_OptionalIdentifier(self, p): |
| """OptionalIdentifier : identifier |
| |""" |
| if len(p) > 1: |
| p[0] = p[1] |
| else: |
| p[0] = '_unnamed_' |
| |
| # [53] |
| def p_ArgumentList(self, p): |
| """ArgumentList : Argument Arguments |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[1], p[2]) |
| |
| # [53.1] ArgumentList error recovery |
| def p_ArgumentListError(self, p): |
| """ArgumentList : error """ |
| p[0] = self.BuildError(p, 'ArgumentList') |
| |
| # [54] |
| def p_Arguments(self, p): |
| """Arguments : ',' Argument Arguments |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [54.1] Arguments error recovery |
| def p_ArgumentsError(self, p): |
| """Arguments : ',' error""" |
| p[0] = self.BuildError(p, 'Arguments') |
| |
| # [55] |
| def p_Argument(self, p): |
| """Argument : ExtendedAttributeList OptionalOrRequiredArgument""" |
| p[2].AddChildren(p[1]) |
| p[0] = p[2] |
| |
| # [56] |
| 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 |
| |
| # [57] |
| def p_ArgumentName(self, p): |
| """ArgumentName : ArgumentNameKeyword |
| | identifier""" |
| p[0] = p[1] |
| |
| # [58] |
| def p_Ellipsis(self, p): |
| """Ellipsis : ELLIPSIS |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildNamed('Argument', p, 1) |
| p[0].AddChildren(self.BuildTrue('ELLIPSIS')) |
| |
| # [] Unspecified |
| def p_ExceptionMember(self, p): |
| """ExceptionMember : Const |
| | ExceptionField""" |
| p[0] = p[1] |
| |
| # [] Unspecified |
| def p_ExceptionField(self, p): |
| """ExceptionField : Type identifier ';'""" |
| p[0] = self.BuildNamed('ExceptionField', p, 2, p[1]) |
| |
| # [] Error recovery for ExceptionMembers - Unspecified |
| def p_ExceptionFieldError(self, p): |
| """ExceptionField : error""" |
| p[0] = self.BuildError(p, 'ExceptionField') |
| |
| # [59] |
| def p_Iterable(self, p): |
| """Iterable : ITERABLE '<' Type OptionalType '>' ';' |
| | LEGACYITERABLE '<' Type '>' ';'""" |
| if len(p) > 6: |
| childlist = ListFromConcat(p[3], p[4]) |
| p[0] = self.BuildProduction('Iterable', p, 2, childlist) |
| else: |
| p[0] = self.BuildProduction('LegacyIterable', p, 2, p[3]) |
| |
| # [60] |
| def p_OptionalType(self, p): |
| """OptionalType : ',' Type |
| |""" |
| if len(p) > 1: |
| p[0] = p[2] |
| |
| # [61] |
| def p_ReadWriteMaplike(self, p): |
| """ReadWriteMaplike : MaplikeRest""" |
| p[0] = p[1] |
| |
| # [62] |
| def p_ReadWriteSetlike(self, p): |
| """ReadWriteSetlike : SetlikeRest""" |
| p[0] = p[1] |
| |
| # [63] |
| def p_MaplikeRest(self, p): |
| """MaplikeRest : MAPLIKE '<' Type ',' Type '>' ';'""" |
| childlist = ListFromConcat(p[3], p[5]) |
| p[0] = self.BuildProduction('Maplike', p, 2, childlist) |
| |
| # [64] |
| def p_SetlikeRest(self, p): |
| """SetlikeRest : SETLIKE '<' Type '>' ';'""" |
| p[0] = self.BuildProduction('Setlike', p, 2, p[3]) |
| |
| # [65] 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) |
| |
| # [65.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] |
| |
| # [66] |
| def p_ExtendedAttributes(self, p): |
| """ExtendedAttributes : ',' ExtendedAttribute ExtendedAttributes |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # We only support: |
| # [ identifier ] |
| # [ identifier ( ArgumentList ) ] |
| # [ identifier = identifier ] |
| # [ identifier = ( IdentifierList ) ] |
| # [ identifier = identifier ( ArgumentList ) ] |
| # [66] map directly to [91-93, 95] |
| # [67-69, 71] are unsupported |
| def p_ExtendedAttribute(self, p): |
| """ExtendedAttribute : ExtendedAttributeNoArgs |
| | ExtendedAttributeArgList |
| | ExtendedAttributeIdent |
| | ExtendedAttributeIdentList |
| | ExtendedAttributeNamedArgList""" |
| p[0] = p[1] |
| |
| # [71] |
| def p_ArgumentNameKeyword(self, p): |
| """ArgumentNameKeyword : ATTRIBUTE |
| | CALLBACK |
| | CONST |
| | CREATOR |
| | DELETER |
| | DICTIONARY |
| | ENUM |
| | EXCEPTION |
| | GETTER |
| | IMPLEMENTS |
| | INHERIT |
| | LEGACYCALLER |
| | PARTIAL |
| | SERIALIZER |
| | SETTER |
| | STATIC |
| | STRINGIFIER |
| | TYPEDEF |
| | UNRESTRICTED""" |
| p[0] = p[1] |
| |
| # [72] NOT IMPLEMENTED (OtherOrComma) |
| |
| # [73] |
| 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])) |
| |
| # [74] |
| 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]) |
| |
| # [75] |
| def p_UnionType(self, p): |
| """UnionType : '(' UnionMemberType OR UnionMemberType UnionMemberTypes ')'""" |
| |
| # [76] |
| def p_UnionMemberType(self, p): |
| """UnionMemberType : NonAnyType |
| | UnionType TypeSuffix |
| | ANY '[' ']' TypeSuffix""" |
| # [77] |
| def p_UnionMemberTypes(self, p): |
| """UnionMemberTypes : OR UnionMemberType UnionMemberTypes |
| |""" |
| |
| # [78] Moved BYTESTRING, DOMSTRING, OBJECT, DATE, REGEXP to PrimitiveType |
| # Moving all built-in types into PrimitiveType makes it easier to |
| # differentiate between them and 'identifier', since p[1] would be a string in |
| # both cases. |
| def p_NonAnyType(self, p): |
| """NonAnyType : PrimitiveType TypeSuffix |
| | PromiseType Null |
| | identifier TypeSuffix |
| | SEQUENCE '<' Type '>' Null |
| | FROZENARRAY '<' 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: |
| cls = 'Sequence' if p[1] == 'sequence' else 'FrozenArray' |
| p[0] = self.BuildProduction(cls, p, 1, ListFromConcat(p[3], p[5])) |
| |
| # [79] NOT IMPLEMENTED (BufferRelatedType) |
| |
| # [80] |
| 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] |
| |
| |
| # [81] Added BYTESTRING, DOMSTRING, OBJECT, DATE, REGEXP |
| def p_PrimitiveType(self, p): |
| """PrimitiveType : UnsignedIntegerType |
| | UnrestrictedFloatType |
| | BOOLEAN |
| | BYTE |
| | OCTET |
| | BYTESTRING |
| | DOMSTRING |
| | OBJECT |
| | DATE |
| | REGEXP""" |
| if type(p[1]) == str: |
| p[0] = self.BuildNamed('PrimitiveType', p, 1) |
| else: |
| p[0] = p[1] |
| |
| |
| # [82] |
| 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 |
| |
| |
| # [83] |
| def p_FloatType(self, p): |
| """FloatType : FLOAT |
| | DOUBLE""" |
| p[0] = p[1] |
| |
| # [84] |
| def p_UnsignedIntegerType(self, p): |
| """UnsignedIntegerType : UNSIGNED IntegerType |
| | IntegerType""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[0] = 'unsigned ' + p[2] |
| |
| # [85] |
| def p_IntegerType(self, p): |
| """IntegerType : SHORT |
| | LONG OptionalLong""" |
| if len(p) == 2: |
| p[0] = p[1] |
| else: |
| p[0] = p[1] + p[2] |
| |
| # [86] |
| def p_OptionalLong(self, p): |
| """OptionalLong : LONG |
| | """ |
| if len(p) > 1: |
| p[0] = ' ' + p[1] |
| else: |
| p[0] = '' |
| |
| # [87] Add unqualified Promise |
| def p_PromiseType(self, p): |
| """PromiseType : PROMISE '<' ReturnType '>' |
| | PROMISE""" |
| if len(p) == 2: |
| # Promise without resolution type is not specified in the Web IDL spec. |
| # As it is used in some specs and in the blink implementation, |
| # we allow that here. |
| resolution_type = self.BuildProduction('Type', p, 1, |
| self.BuildProduction('Any', p, 1)) |
| p[0] = self.BuildNamed('Promise', p, 1, resolution_type) |
| else: |
| p[0] = self.BuildNamed('Promise', p, 1, p[3]) |
| |
| # [88] 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]) |
| |
| |
| # [89] |
| def p_TypeSuffixStartingWithArray(self, p): |
| """TypeSuffixStartingWithArray : '[' ']' TypeSuffix |
| | """ |
| if len(p) > 1: |
| p[0] = self.BuildProduction('Array', p, 0, p[3]) |
| |
| # [90] |
| def p_Null(self, p): |
| """Null : '?' |
| |""" |
| if len(p) > 1: |
| p[0] = self.BuildTrue('NULLABLE') |
| |
| # [91] |
| 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] |
| |
| # [92] |
| def p_IdentifierList(self, p): |
| """IdentifierList : identifier Identifiers""" |
| p[0] = ListFromConcat(p[1], p[2]) |
| |
| # [93] |
| def p_Identifiers(self, p): |
| """Identifiers : ',' identifier Identifiers |
| |""" |
| if len(p) > 1: |
| p[0] = ListFromConcat(p[2], p[3]) |
| |
| # [94] |
| def p_ExtendedAttributeNoArgs(self, p): |
| """ExtendedAttributeNoArgs : identifier""" |
| p[0] = self.BuildNamed('ExtAttribute', p, 1) |
| |
| # [95] |
| def p_ExtendedAttributeArgList(self, p): |
| """ExtendedAttributeArgList : identifier '(' ArgumentList ')'""" |
| arguments = self.BuildProduction('Arguments', p, 2, p[3]) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, arguments) |
| |
| # [96] |
| def p_ExtendedAttributeIdent(self, p): |
| """ExtendedAttributeIdent : identifier '=' identifier""" |
| value = self.BuildAttribute('VALUE', p[3]) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, value) |
| |
| # [97] |
| def p_ExtendedAttributeIdentList(self, p): |
| """ExtendedAttributeIdentList : identifier '=' '(' IdentifierList ')'""" |
| value = self.BuildAttribute('VALUE', p[4]) |
| p[0] = self.BuildNamed('ExtAttribute', p, 1, value) |
| |
| # [98] |
| 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:])) |
