webidl 0.0.1

data/lib/webidl/parse_tree/interface.rb

@@ -0,0 +1,21 @@
+module WebIDL
+  module ParseTree
+    class Interface < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        intf = Ast::Interface.new(parent, name.text_value)
+
+        unless members.empty?
+          members.build(intf)
+        end
+
+        unless inherits.empty?
+          intf.inherits = inherits.build(parent)
+        end
+
+        intf
+      end
+
+    end # Interface
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/interface_inheritance.rb

@@ -0,0 +1,11 @@
+module WebIDL
+  module ParseTree
+    class InterfaceInheritance < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        names.build(parent)
+      end
+
+    end # InterfaceInheritance
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/interface_members.rb

@@ -0,0 +1,21 @@
+module WebIDL
+  module ParseTree
+    class InterfaceMembers < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        m = member.build(parent)
+        m.extended_attributes = eal.build(parent) unless eal.empty?
+
+        list = [m]
+        list += members.build(parent) unless members.empty?
+
+        if parent
+          parent.members = list
+        end
+
+        list
+      end
+
+    end # InterfaceMembers
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/module.rb

@@ -0,0 +1,15 @@
+module WebIDL
+  module ParseTree
+    class Module < Treetop::Runtime::SyntaxNode
+
+      def build(parent = nil)
+        m = Ast::Module.new(parent, name.text_value)
+
+        defs.build(m)
+
+        m
+      end
+
+    end # Module
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/nullable_type.rb

@@ -0,0 +1,11 @@
+module WebIDL
+  module ParseTree
+    class NullableType < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        Ast::Type.new parent, type.text_value, :nullable => null.any?
+      end
+
+    end # NullableType
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/operation.rb

@@ -0,0 +1,30 @@
+module WebIDL
+  module ParseTree
+    class Operation < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        if respond_to?(:specials)
+          special_list = specials.build unless specials.empty?
+          operation    = op
+        else
+          special_list = []
+          operation    = self
+        end
+
+        debugger unless operation.type.respond_to?(:build)
+        typ        = operation.type.build(parent)
+        name       = operation.optional_id.text_value unless operation.optional_id.empty?
+        arguments  = operation.args.build(parent) unless operation.args.empty?
+        raise_list = operation.raises.build unless operation.raises.empty?
+
+        Ast::Operation.new(
+          parent, typ,  :name     => name,
+                        :specials => special_list,
+                        :args     => arguments,
+                        :raises   => raise_list
+        )
+      end
+
+    end # Operation
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/relative_scoped_name.rb

@@ -0,0 +1,15 @@
+module WebIDL
+  module ParseTree
+    class RelativeScopedName < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        n = ''
+        n << name.text_value
+        n << parts.text_value
+
+        sn = Ast::ScopedName.new(parent, n, :relative => true)
+      end
+
+    end # RelativeScopedName
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/scoped_name_list.rb

@@ -0,0 +1,16 @@
+module WebIDL
+  module ParseTree
+    class ScopedNameList < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        result = []
+
+        result << name.build(parent)
+        result += names.build(parent) unless names.empty?
+
+        result
+      end
+
+    end # ScopedNameList
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/specials.rb

@@ -0,0 +1,17 @@
+module WebIDL
+  module ParseTree
+    class Specials < Treetop::Runtime::SyntaxNode
+
+      def build
+        result = []
+
+        result << first.text_value
+        result += rest.build unless rest.empty?
+
+        result
+      end
+
+
+    end # Specials
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/stringifier_attribute_or_operation.rb

@@ -0,0 +1,16 @@
+module WebIDL
+  module ParseTree
+    class StringifierAttributeOrOperation < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        unless a_or_op.empty? || a_or_op.text_value == ";"
+          elem = a_or_op.build(parent)
+          elem.stringifier = true
+
+          elem
+        end
+      end
+
+    end # StringifierAttributeOrOperation
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/typedef.rb

@@ -0,0 +1,11 @@
+module WebIDL
+  module ParseTree
+    class TypeDef < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        Ast::TypeDef.new(parent, type.text_value, name.text_value)
+      end
+
+    end # TypeDef
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parser/debug_helper.rb

@@ -0,0 +1,17 @@
+module WebIDL
+  module Parser
+    module DebugHelper
+
+      def terminal_parse_failure(*args)
+        p :terminal_parse_failure => args
+        super
+      end
+
+      def instantiate_node(node, input, interval, *args)
+        p :instantiating_from => caller.first[/in `(.+)'/, 1], :str => input[interval]
+        super
+      end
+
+    end # DebugHelper
+  end # Parser
+end # WebIDL

data/lib/webidl/parser/idl.treetop

@@ -0,0 +1,369 @@
+module WebIDL
+  module Parser
+
+    # http://dev.w3.org/2006/webapi/WebIDL/#idl-grammar
+    grammar IDL
+
+      rule Definitions
+        ws metadef:(eal:ExtendedAttributeList ws d:Definition ws defs:Definitions)? ws <ParseTree::Definitions>
+      end
+
+      rule Definition
+          Module
+        / Interface
+        / Exception
+        / TypeDef
+        / ImplementsStatement
+      end
+
+      rule Module
+        "module" ws name:identifier ws "{" ws defs:Definitions ws "}" ws ";" <ParseTree::Module>
+      end
+
+      rule Interface
+        "interface" ws name:identifier ws inherits:InterfaceInheritance ws "{" ws members:InterfaceMembers ws "}" ws ";" <ParseTree::Interface>
+      end
+
+      rule InterfaceInheritance
+        (":" ws names:ScopedNameList <ParseTree::InterfaceInheritance>)?
+      end
+
+      # extract to a generic Members syntax node?
+      rule InterfaceMembers
+        (eal:ExtendedAttributeList ws member:InterfaceMember ws members:InterfaceMembers ws <ParseTree::InterfaceMembers>)?
+      end
+
+      rule InterfaceMember
+        Const / AttributeOrOperation
+      end
+
+      rule Exception
+        "exception" ws name:identifier ws "{" ws members:ExceptionMembers ws "}" ws ";" <ParseTree::Exception>
+      end
+
+      # extract to a generic Members syntax node?
+      rule ExceptionMembers
+        (eal:ExtendedAttributeList ws member:ExceptionMember ws members:ExceptionMembers ws <ParseTree::InterfaceMembers>)?
+      end
+
+      rule TypeDef
+        "typedef" ws type:Type ws name:identifier ws ";" <ParseTree::TypeDef>
+      end
+
+      rule ImplementsStatement
+        implementor:ScopedName ws "implements" ws implementee:ScopedName ws ";" <ParseTree::ImplementsStatement>
+      end
+
+      rule Const
+        "const" ws type:Type ws name:identifier ws "=" ws const_expr:ConstExpr ws ";" <ParseTree::Const>
+      end
+
+      rule ConstExpr
+        BooleanLiteral / integer / float
+      end
+
+      rule BooleanLiteral
+        ("true" / "false") { def build() text_value == "true" end }
+      end
+
+      rule AttributeOrOperation
+        StringifierAttributeOrOperation / Attribute / Operation
+      end
+
+      rule StringifierAttributeOrOperation
+        "stringifier" ws a_or_op:(Attribute / OperationRest / ";") <ParseTree::StringifierAttributeOrOperation>
+      end
+
+      rule Attribute
+        readonly:ReadOnly ws "attribute" ws type:Type ws name:identifier ws getraises:GetRaises ws setraises:SetRaises ws ";" <ParseTree::Attribute>
+      end
+
+      rule ReadOnly
+        "readonly"?
+      end
+
+      rule GetRaises
+        ("getraises" ws list:ExceptionList)?
+      end
+
+      rule SetRaises
+        ("setraises" ws list:ExceptionList)?
+      end
+
+      rule Operation
+        specials:(OmittableSpecials / Specials) ws op:OperationRest <ParseTree::Operation>
+      end
+
+      rule OmittableSpecials
+        omit:"omittable" ws Specials <ParseTree::OmittableSpecials>
+      end
+
+      rule Specials
+        (first:Special ws rest:Specials <ParseTree::Specials>)?
+      end
+
+      rule Special
+          "getter"
+        / "setter"
+        / "creator"
+        / "deleter"
+        / "caller"
+      end
+
+      rule OperationRest
+        type:ReturnType ws optional_id:OptionalIdentifier ws "(" ws args:ArgumentList ws ")" ws raises:Raises ws ";" <ParseTree::Operation>
+      end
+
+      rule OptionalIdentifier
+        identifier?
+      end
+
+      rule Raises
+        ("raises" ExceptionList)?
+      end
+
+      rule ExceptionList
+        "(" ScopedNameList ")"
+      end
+
+      rule ArgumentList
+        (arg:Argument ws args:Arguments <ParseTree::ArgumentList>)?
+      end
+
+      rule Arguments
+        ("," ws arg:Argument ws args:Arguments <ParseTree::ArgumentList>)?
+      end
+
+      rule Argument
+        eal:ExtendedAttributeList ws In ws optional:Optional ws type:Type ws variadic:Ellipsis ws id:identifier <ParseTree::Argument>
+      end
+
+      rule In
+        "in"?
+      end
+
+      rule Optional
+        "optional"?
+      end
+
+      rule Ellipsis
+        "..."?
+      end
+
+      rule ExceptionMember
+        Const / ExceptionField
+      end
+
+      rule ExceptionField
+        type:Type ws id:identifier ws ";" <ParseTree::ExceptionField>
+      end
+
+      rule ExtendedAttributeList
+        ("[" ws attribute:ExtendedAttribute ws attributes:ExtendedAttributes ws "]" <ParseTree::ExtendedAttributeList>)?
+      end
+
+      rule ExtendedAttributes
+        ("," ws attribute:ExtendedAttribute ws attributes:ExtendedAttributes <ParseTree::ExtendedAttributeList>)?
+      end
+
+
+      #
+      # avoid infinite recursion trouble with the actual spec by using the "more restricted" ones
+      #
+
+      rule ExtendedAttribute
+          ExtendedAttributeNamedArgList
+        / ExtendedAttributeIdent
+        / ExtendedAttributeScopedName
+        / ExtendedAttributeArgList
+        / ExtendedAttributeNoArg
+      end
+
+      rule ExtendedAttributeNoArg
+        identifier {
+          def build(parent)
+            Ast::ExtendedAttribute.new(text_value)
+          end
+        }
+      end
+
+      rule ExtendedAttributeArgList
+        name:identifier "(" ws args:ArgumentList ws ")" <ParseTree::ExtendedAttributeArgList>
+      end
+
+      rule ExtendedAttributeScopedName
+        key:identifier "=" scoped_name:ScopedName <ParseTree::ExtendedAttributeScopedName>
+      end
+
+      rule ExtendedAttributeIdent
+        key:identifier "=" value:identifier !"::" <ParseTree::ExtendedAttributeIdent>
+      end
+
+      rule ExtendedAttributeNamedArgList
+        key:identifier "=" value:(name:identifier "(" ws args:ArgumentList ws ")" <ParseTree::ExtendedAttributeArgList>) <ParseTree::ExtendedAttributeNamedArgList>
+      end
+
+
+    #  rule ExtendedAttribute
+    #      "(" ws ExtendedAttributeInner ws ")" ws ExtendedAttributeRest
+    #    / "[" ws ExtendedAttributeInner ws "]" ws ExtendedAttributeRest
+    #    / "{" ws ExtendedAttributeInner ws "}" ws ExtendedAttributeRest
+    #    / Other ws ExtendedAttributeRest
+    #  end
+    #
+    #  rule ExtendedAttributeRest
+    #    ExtendedAttribute?
+    #  end
+    #
+    #  rule ExtendedAttributeInner
+    #    ( "(" ws ExtendedAttributeInner ws ")" ws ExtendedAttributeInner
+    #    / "[" ws ExtendedAttributeInner ws "]" ws ExtendedAttributeInner
+    #    / "{" ws ExtendedAttributeInner ws "}" ws ExtendedAttributeInner
+    #    / OtherOrComma ExtendedAttributeInner)?
+    #  end
+    #
+      rule Other
+          integer
+        / float
+        / identifier
+        / string
+        / other
+        / ":"
+        / "::"
+        / ";"
+        / "<"
+        / "="
+        / ">"
+        / "DOMString"
+        / "FALSE"
+        / "Object"
+        / "TRUE"
+        / "any"
+        / "attribute"
+        / "boolean"
+        / "const"
+        / "exception"
+        / "float"
+        / "getraises"
+        / "in"
+        / "interface"
+        / "long"
+        / "module"
+        / "octet"
+        / "raises"
+        / "sequence"
+        / "setraises"
+        / "short"
+        / "typedef"
+        / "unsigned"
+        / "valuetype"
+      end
+
+      rule OtherOrComma
+        Other / ","
+      end
+
+      rule Type
+          NullableType
+        / ScopedName
+        / "any"
+        / "object"
+      end
+
+      #
+      # added: cannot be followed by a NonSpace character, since e.g. DOMStringMap would break parsing
+      #
+
+      rule NullableType
+          type:UnsignedIntegerType              null:Nullable           <ParseTree::NullableType>
+        / type:"boolean"                        null:Nullable !NonSpace <ParseTree::NullableType>
+        / type:"octet"                          null:Nullable !NonSpace <ParseTree::NullableType>
+        / type:"float"                          null:Nullable !NonSpace <ParseTree::NullableType>
+        / type:"double"                         null:Nullable !NonSpace <ParseTree::NullableType>
+        / type:"DOMString"                      null:Nullable !NonSpace <ParseTree::NullableType>
+        / type:"sequence" ws "<" ws Type ws ">" null:Nullable !NonSpace <ParseTree::NullableType>
+      end
+
+      rule UnsignedIntegerType
+        "unsigned" ws IntegerType / IntegerType
+      end
+
+      rule IntegerType
+        ("short" / "long" ws OptionalLong)
+      end
+
+      rule OptionalLong
+        "long"?
+      end
+
+      rule Nullable
+        "?"?
+      end
+
+      rule NonSpace
+        (!' ' .)
+      end
+
+      rule ReturnType
+        Type / "void" <ParseTree::VoidType>
+      end
+
+      rule ScopedNameList
+        name:ScopedName ws names:ScopedNames  <ParseTree::ScopedNameList>
+      end
+
+      rule ScopedNames
+        ("," ScopedName ws ScopedNames)?
+      end
+
+      rule ScopedName
+        AbsoluteScopedName / RelativeScopedName
+      end
+
+      rule AbsoluteScopedName
+        "::" name:identifier parts:ScopedNameParts <ParseTree::AbsoluteScopedName>
+      end
+
+      rule RelativeScopedName
+        name:identifier parts:ScopedNameParts <ParseTree::RelativeScopedName>
+      end
+
+      rule ScopedNameParts
+        ("::" ws name:identifier parts:ScopedNameParts)?
+      end
+
+      rule integer
+        ("-"? "0" ([0-7]* / [Xx] [0-9A-Fa-f]+) / [1-9] [0-9]*) { def build() Integer(text_value) end} # TODO: check edge cases
+      end
+
+      rule float
+        ("-"? ([0-9]+ "." [0-9]* / [0-9]* "." [0-9]+) ([Ee] [+-]? [0-9]+)? / [0-9]+ [Ee] [+-]? [0-9]+) { def build() Float(text_value) end} # TODO: check edge cases
+      end
+
+      rule identifier
+        [A-Z_a-z] [0-9A-Z_a-z]* { def build() text_value[/^_?(.+)/, 1] end}
+      end
+
+      rule string
+        "\"" [^"]* "\""
+      end
+
+      rule ws
+        ([\t\n\r ]* ((line_comment /  block_comment) [\t\n\r ]*)+ / [\t\n\r ]+)?
+      end
+
+      rule other
+        [^\t\n\r 0-9A-Z_a-z]
+      end
+
+      rule line_comment
+        "//" (![\n\r] . )*
+      end
+
+      rule block_comment
+         '/*' (!'*/' . )* '*/'
+      end
+
+    end # IDL
+  end # Parser
+end # WebIDL