tools/dom/scripts/idlparser.dart - sdk - Git at Google

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 // IDL grammar variants.
 const int WEBIDL_SYNTAX = 0;
 const int WEBKIT_SYNTAX = 1;
 const int FREMONTCUT_SYNTAX = 2;

 /**
  * IDLFile is the top-level node in each IDL file. It may contain modules or
  * interfaces.
  */
 class IDLFile extends IDLNode {

   String filename;
   List<IDLModule> modules;
   List<IDLInterface> interfaces;

   IDLFile(this.filename, this.modules, this.interfaces);
 }

 /**
  * IDLModule has an id, and may contain interfaces, type defs and implements
  * statements.
  */
 class IDLModule extends IDLNode {
   String id;
   List interfaces;
   List typedefs;
   List implementsStatements;

   IDLModule(String this.id, IDLExtAttrs extAttrs, IDLAnnotations annotations,
             List<IDLNode> elements) {
     setExtAttrs(extAttrs);
     this.annotations = annotations;
     this.interfaces = elements.where((e) => e is IDLInterface).toList();
     this.typedefs = elements.where((e) => e is IDLTypeDef).toList();
     this.implementsStatements =
         elements.where((e) => e is IDLImplementsStatement).toList();
   }

   toString() => '<IDLModule $id $extAttrs $annotations>';
 }

 class IDLNode {
   IDLExtAttrs extAttrs;
   IDLAnnotations annotations;
   IDLNode();

   setExtAttrs(IDLExtAttrs ea) {
     assert(ea != null);
     this.extAttrs = ea != null ? ea : new IDLExtAttrs();
   }
 }

 class IDLType extends IDLNode {
   String id;
   IDLType parameter;
   bool nullable = false;
   IDLType(String this.id, [IDLType this.parameter, bool this.nullable = false]);

   // TODO: Figure out why this constructor was failing in mysterious ways.
   // IDLType.nullable(IDLType base) {
   //   return new IDLType(base.id, base.parameter, true);
   // }

   //String toString() => '<IDLType $nullable $id $parameter>';
   String toString() {
     String nullableTag = nullable ? '?' : '';
     return '<IDLType $id${parameter == null ? '' : ' $parameter'}$nullableTag>';
   }
 }

 class IDLTypeDef extends IDLNode {
   String id;
   IDLType type;
   IDLTypeDef(String this.id, IDLType this.type);

   toString() => '<IDLTypeDef $id $type>';
 }

 class IDLImplementsStatement extends IDLNode {
 }

 class IDLInterface extends IDLNode {
   String id;
   List parents;
   List operations;
   List attributes;
   List constants;
   List snippets;

   bool isSupplemental;
   bool isNoInterfaceObject;
   bool isFcSuppressed;

   IDLInterface(String this.id, IDLExtAttrs ea, IDLAnnotations ann,
                List this.parents, List members) {
     setExtAttrs(ea);
     this.annotations = ann;
     if (this.parents == null) this.parents = [];

     operations = members.where((e) => e is IDLOperation).toList();
     attributes = members.where((e) => e is IDLAttribute).toList();
     constants = members.where((e) => e is IDLConstant).toList();
     snippets = members.where((e) => e is IDLSnippet).toList();

     isSupplemental = extAttrs.has('Supplemental');
     isNoInterfaceObject = extAttrs.has('NoInterfaceObject');
     isFcSuppressed = extAttrs.has('Suppressed');
   }

   toString() => '<IDLInterface $id $extAttrs $annotations>';
 }

 class IDLMember extends IDLNode {
   String id;
   IDLType type;
   bool isFcSuppressed;

   IDLMember(String this.id, IDLType this.type, IDLExtAttrs ea, IDLAnnotations ann) {
     setExtAttrs(ea);
     this.annotations = ann;

     isFcSuppressed = extAttrs.has('Suppressed');
   }
 }

 class IDLOperation extends IDLMember {
   List arguments;

   // Ignore all forms of raises for now.
   List specials;
   bool isStringifier;

   IDLOperation(String id, IDLType type, IDLExtAttrs ea, IDLAnnotations ann,
                List this.arguments, List this.specials, bool this.isStringifier)
       : super(id, type, ea, ann) {
   }

   toString() => '<IDLOperation $type $id ${printList(arguments)}>';
 }

 class IDLAttribute extends IDLMember {
 }

 class IDLConstant extends IDLMember {
   var value;
   IDLConstant(String id, IDLType type, IDLExtAttrs ea, IDLAnnotations ann,
               var this.value)
       : super(id, type, ea, ann);
 }

 class IDLSnippet extends IDLMember {
   String text;
   IDLSnippet(IDLAnnotations ann, String this.text)
       : super(null, null, new IDLExtAttrs(), ann);
 }

 /** Maps string to something. */
 class IDLDictNode {
   Map<String, Object> map;
   IDLDictNode() {
     map = new Map<String, Object>();
   }

   setMap(List associationList) {
     if (associationList == null) return;
     for (var element in associationList) {
       var name = element[0];
       var value = element[1];
       map[name] = value;
     }
   }

   bool has(String key) => map.containsKey(key);

   formatMap() {
     if (map.isEmpty)
       return '';
     StringBuffer sb = new StringBuffer();
     map.forEach((k, v) {
         sb.add(' $k');
         if (v != null) {
           sb.add('=$v');
         }
       });
     return sb.toString();
   }

 }

 class IDLExtAttrs extends IDLDictNode {
   IDLExtAttrs([List attrs = const []]) : super() {
     setMap(attrs);
   }

   toString() => '<IDLExtAttrs${formatMap()}>';
 }

 class IDLArgument extends IDLNode {
   String id;
   IDLType type;
   bool isOptional;
   bool isIn;
   bool hasElipsis;
   IDLArgument(String this.id, IDLType this.type, IDLExtAttrs extAttrs,
               bool this.isOptional, bool this.isIn, bool this.hasElipsis) {
     setExtAttrs(extAttrs);
   }

   toString() => '<IDLArgument $id>';
 }

 class IDLAnnotations extends IDLDictNode {
   IDLAnnotations(List annotations) : super() {
     for (var annotation in annotations) {
       map[annotation.id] = annotation;
     }
   }

   toString() => '<IDLAnnotations${formatMap()}>';
 }

 class IDLAnnotation extends IDLDictNode {
   String id;
   IDLAnnotation(String this.id, List args) : super() {
     setMap(args);
   }

   toString() => '<IDLAnnotation $id${formatMap()}>';
 }

 class IDLExtAttrFunctionValue extends IDLNode {
   String name;
   List arguments;
   IDLExtAttrFunctionValue(String this.name, this.arguments);

   toString() => '<IDLExtAttrFunctionValue $name(${arguments.length})>';
 }

 class IDLParentInterface extends IDLNode {}

 ////////////////////////////////////////////////////////////////////////////////

 class IDLParser {
   final int syntax;
   Grammar grammar;
   var axiom;

   IDLParser([syntax=WEBIDL_SYNTAX]) : syntax = syntax {
     grammar = new Grammar();
     axiom = _makeParser();
   }

   syntax_switch([WebIDL, WebKit, FremontCut]) {
     assert(WebIDL != null && WebKit != null);  // Not options, just want names.
     if (syntax == WEBIDL_SYNTAX)
       return WebIDL;
     if (syntax == WEBKIT_SYNTAX)
       return WebKit;
     if (syntax == FREMONTCUT_SYNTAX)
       return FremontCut == null ?  WebIDL : FremontCut;
     throw new Exception('unsupported IDL syntax $syntax');
   }

   _makeParser() {
     Grammar g = grammar;

     // TODO: move syntax_switch back to here.

     var idStartCharSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_';
     var idNextCharSet = idStartCharSet + '0123456789';
     var hexCharSet = '0123456789ABCDEFabcdef';

     var idStartChar = CHAR(idStartCharSet);
     var idNextChar = CHAR(idNextCharSet);

     var digit = CHAR('0123456789');

     var Id = TEXT(LEX('an identifier',[idStartChar, MANY(idNextChar, min:0)]));

     var IN = SKIP(LEX("'in'", ['in',NOT(idNextChar)]));

     var BooleanLiteral = OR(['true', 'false']);
     var IntegerLiteral = TEXT(LEX('hex-literal', OR([['0x', MANY(CHAR(hexCharSet))],
                                       [MANY(digit)]])));
     var FloatLiteral = TEXT(LEX('float-literal', [MANY(digit), '.', MANY(digit, min:0)]));


     var Argument = g['Argument'];
     var Module = g['Module'];
     var Member = g['Member'];
     var Interface = g['Interface'];
     var ExceptionDef = g['ExceptionDef'];
     var Type = g['Type'];
     var TypeDef = g['TypeDef'];
     var ImplStmt = g['ImplStmt'];
     var ValueTypeDef = g['ValueTypeDef'];
     var Const = g['Const'];
     var Attribute = g['Attribute'];
     var Operation = g['Operation'];
     var Snippet = g['Snippet'];
     var ExtAttrs = g['ExtAttrs'];
     var MaybeExtAttrs = g['MaybeExtAttrs'];
     var MaybeAnnotations = g['MaybeAnnotations'];
     var ParentInterfaces = g['ParentInterfaces'];


     final ScopedName = TEXT(LEX('scoped-name', MANY(CHAR(idStartCharSet + '_:.<>'))));

     final ScopedNames = MANY(ScopedName, separator:',');

     // Types

     final IntegerTypeName = OR([
         ['byte', () => 'byte'],
         ['int', () => 'int'],
         ['long', 'long', () => 'long long'],
         ['long', () => 'long'],
         ['octet', () => 'octet'],
         ['short', () => 'short']]);

     final IntegerType = OR([
         ['unsigned', IntegerTypeName, (name) => new IDLType('unsigned $name')],
         [IntegerTypeName, (name) => new IDLType(name)]]);

     final BooleanType = ['boolean', () => new IDLType('boolean')];
     final OctetType = ['octet', () => new IDLType('octet')];
     final FloatType = ['float', () => new IDLType('float')];
     final DoubleType = ['double', () => new IDLType('double')];

     final SequenceType = ['sequence', '<', Type, '>',
                           (type) => new IDLType('sequence', type)];

     final ScopedNameType = [ScopedName, (name) => new IDLType(name)];

     final NullableType =
         [OR([IntegerType, BooleanType, OctetType, FloatType,
              DoubleType, SequenceType, ScopedNameType]),
          MAYBE('?'),
          (type, nullable) =>
              nullable ? new IDLType(type.id, type.parameter, true) : type];

     final VoidType = ['void', () => new IDLType('void')];
     final AnyType = ['any', () => new IDLType('any')];
     final ObjectType = ['object', () => new IDLType('object')];

     Type.def = OR([AnyType, ObjectType, NullableType]);

     final ReturnType = OR([VoidType, Type]);

     var Definition = syntax_switch(
         WebIDL: OR([Module, Interface, ExceptionDef, TypeDef, ImplStmt,
                     ValueTypeDef, Const]),
         WebKit: OR([Module, Interface]));

     var Definitions = MANY(Definition, min:0);

     Module.def = syntax_switch(
         WebIDL: [MaybeExtAttrs, 'module', Id, '{', Definitions, '}',
                  SKIP(MAYBE(';')),
                  (ea, id, defs) => new IDLModule(id, ea, null, defs)],
         WebKit: ['module', MaybeExtAttrs, Id, '{', Definitions, '}',
                  SKIP(MAYBE(';')),
                  (ea, id, defs) => new IDLModule(id, ea, null, defs)],
         FremontCut: [MaybeAnnotations, MaybeExtAttrs, 'module', Id,
                      '{', Definitions, '}', SKIP(MAYBE(';')),
                      (ann, ea, id, defs) => new IDLModule(id, ea, ann, defs)]);

     Interface.def = syntax_switch(
         WebIDL: [MaybeExtAttrs, 'interface', Id, MAYBE(ParentInterfaces),
                  MAYBE(['{', MANY0(Member), '}']), ';',
                  (ea, id, p, ms) => new IDLInterface(id, ea, null, p, ms)],
         WebKit: ['interface', MaybeExtAttrs, Id, MAYBE(ParentInterfaces),
                  MAYBE(['{', MANY0(Member), '}']), ';',
                  (ea, id, p, ms) => new IDLInterface(id, ea, null, p, ms)],
         FremontCut: [MaybeAnnotations, MaybeExtAttrs, 'interface',
                      Id, MAYBE(ParentInterfaces),
                      MAYBE(['{', MANY0(Member), '}']), ';',
                      (ann, ea, id, p, ms) => new IDLInterface(id, ea, ann, p, ms)]);

     Member.def = syntax_switch(
         WebIDL: OR([Const, Attribute, Operation, ExtAttrs]),
         WebKit: OR([Const, Attribute, Operation]),
         FremontCut: OR([Const, Attribute, Operation, Snippet]));

     var InterfaceType = ScopedName;

     var ParentInterface = syntax_switch(
         WebIDL: [InterfaceType],
         WebKit: [InterfaceType],
         FremontCut: [MaybeAnnotations, InterfaceType]);

     ParentInterfaces.def = [':', MANY(ParentInterface, ',')];

     // TypeDef (Web IDL):
     TypeDef.def = ['typedef', Type, Id, ';', (type, id) => new IDLTypeDef(id, type)];

     // TypeDef (Old-school W3C IDLs)
     ValueTypeDef.def = ['valuetype', Id, Type, ';'];

     // Implements Statement (Web IDL):
     var ImplStmtImplementor = ScopedName;
     var ImplStmtImplemented = ScopedName;

     ImplStmt.def = [ImplStmtImplementor, 'implements', ImplStmtImplemented, ';'];

     var ConstExpr = OR([BooleanLiteral, IntegerLiteral, FloatLiteral]);

     Const.def = syntax_switch(
         WebIDL: [MaybeExtAttrs, 'const', Type, Id, '=', ConstExpr, ';',
                  (ea, type, id, v) => new IDLConstant(id, type, ea, null, v)],
         WebKit: ['const', MaybeExtAttrs, Type, Id, '=', ConstExpr, ';',
                  (ea, type, id, v) => new IDLConstant(id, type, ea, null, v)],
         FremontCut: [MaybeAnnotations, MaybeExtAttrs,
                      'const', Type, Id, '=', ConstExpr, ';',
                      (ann, ea, type, id, v) =>
                          new IDLConstant(id, type, ea, ann, v)]);

     // Attributes

     var Stringifier = 'stringifier';
     var AttrGetter = 'getter';
     var AttrSetter = 'setter';
     var ReadOnly = 'readonly';
     var AttrGetterSetter = OR([AttrGetter, AttrSetter]);

     var GetRaises = syntax_switch(
         WebIDL: ['getraises', '(', ScopedNames, ')'],
         WebKit: ['getter', 'raises', '(', ScopedNames, ')']);

     var SetRaises = syntax_switch(
         WebIDL: ['setraises', '(', ScopedNames, ')'],
         WebKit: ['setter', 'raises', '(', ScopedNames, ')']);

     var Raises = ['raises', '(', ScopedNames, ')'];

     var AttrRaises = syntax_switch(
         WebIDL: MANY(OR([GetRaises, SetRaises])),
         WebKit: MANY(OR([GetRaises, SetRaises, Raises]), separator:','));

     Attribute.def = syntax_switch(
         WebIDL: [MaybeExtAttrs, MAYBE(Stringifier), MAYBE(ReadOnly),
                  'attribute', Type, Id, MAYBE(AttrRaises), ';'],
         WebKit: [MAYBE(Stringifier), MAYBE(ReadOnly), 'attribute',
                  MaybeExtAttrs, Type, Id, MAYBE(AttrRaises), ';'],
         FremontCut: [MaybeAnnotations, MaybeExtAttrs,
                      MAYBE(AttrGetterSetter), MAYBE(Stringifier), MAYBE(ReadOnly),
                      'attribute', Type, Id, MAYBE(AttrRaises), ';'
                      ]);

     // Operations

     final Special = TEXT(OR(['getter', 'setter', 'creator', 'deleter', 'caller']));
     final Specials = MANY(Special);

     final Optional = 'optional';
     final AnEllipsis = '...';

     Argument.def = syntax_switch(
         WebIDL: SEQ(MaybeExtAttrs, MAYBE(Optional), MAYBE(IN),
                     MAYBE(Optional), Type, MAYBE(AnEllipsis), Id,
                     (e, opt1, isin, opt2, type, el, id) =>
                         new IDLArgument(id, type, e, opt1 || opt2, isin, el)),

         WebKit: SEQ(MAYBE(Optional), MAYBE('in'), MAYBE(Optional),
                     MaybeExtAttrs, Type, Id
                     (opt1, isin, opt2, e, type, id) =>
                         new IDLArgument(id, type, e, opt1 || opt2, isin, false)));

     final Arguments = MANY0(Argument, ',');

     Operation.def = syntax_switch(
         WebIDL: [MaybeExtAttrs, MAYBE(Stringifier), MAYBE(Specials),
                  ReturnType, MAYBE(Id), '(', Arguments, ')', MAYBE(Raises), ';',
                  (ea, isStringifier, specials, type, id, args, raises) =>
                      new IDLOperation(id, type, ea, null, args, specials, isStringifier)
                  ],
         WebKit: [MaybeExtAttrs, ReturnType, MAYBE(Id), '(', Arguments, ')',
                  MAYBE(Raises), ';',
                  (ea, type, id, args, raises) =>
                      new IDLOperation(id, type, ea, null, args, [], false)
                  ],
         FremontCut: [MaybeAnnotations, MaybeExtAttrs, MAYBE(Stringifier),
                      MAYBE(Specials), ReturnType, MAYBE(Id), '(', Arguments, ')',
                      MAYBE(Raises), ';',
                      (ann, ea, isStringifier, specials, type, id, args, raises) =>
                        new IDLOperation(id, type, ea, ann, args, specials, isStringifier)
                      ]);

     // Exceptions

     final ExceptionField = [Type, Id, ';'];
     final ExceptionMember = OR([Const, ExceptionField, ExtAttrs]);
     ExceptionDef.def = ['exception', Id, '{', MANY0(ExceptionMember), '}', ';'];

     // ExtendedAttributes

     var ExtAttrArgList = ['(', MANY0(Argument, ','), ')'];

     var ExtAttrFunctionValue =
         [Id, '(', MANY0(Argument, ','), ')',
          (name, args) => new IDLExtAttrFunctionValue(name, args)
          ];

     var ExtAttrValue = OR([ExtAttrFunctionValue,
                            TEXT(LEX('value', MANY(CHAR(idNextCharSet + '&:-|'))))]);

     var ExtAttr = [Id, MAYBE(OR([['=', ExtAttrValue], ExtAttrArgList]))];

     ExtAttrs.def = ['[', MANY(ExtAttr, ','), ']',
                     (list) => new IDLExtAttrs(list)];;

     MaybeExtAttrs.def = OR(ExtAttrs,
                            [ () => new IDLExtAttrs() ] );

     // Annotations - used in the FremontCut IDL grammar.

     var AnnotationArgValue = TEXT(LEX('xx', MANY(CHAR(idNextCharSet + '&:-|'))));

     var AnnotationArg = [Id, MAYBE(['=', AnnotationArgValue])];

     var AnnotationBody = ['(', MANY0(AnnotationArg, ','), ')'];

     var Annotation = ['@', Id, MAYBE(AnnotationBody),
                       (id, body) => new IDLAnnotation(id, body)];

     MaybeAnnotations.def = [MANY0(Annotation), (list) => new IDLAnnotations(list)];

     // Snippets - used in the FremontCut IDL grammar.

     final SnippetText = TEXT(LEX('snippet body', MANY0([NOT('}'), CHAR()])));
     Snippet.def = [MaybeAnnotations, 'snippet', '{', SnippetText, '}', ';',
                    (ann, text) => new IDLSnippet(ann, text)];


     grammar.whitespace =
         OR([MANY(CHAR(' \t\r\n')),
             ['//', MANY0([NOT(CHAR('\r\n')), CHAR()])],
             ['#', MANY0([NOT(CHAR('\r\n')), CHAR()])],
             ['/*', MANY0([NOT('*/'), CHAR()]), '*/']]);

     // Top level - at least one definition.
     return MANY(Definition);

   }
 }
	// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	// IDL grammar variants.
	const int WEBIDL_SYNTAX = 0;
	const int WEBKIT_SYNTAX = 1;
	const int FREMONTCUT_SYNTAX = 2;

	/**
	* IDLFile is the top-level node in each IDL file. It may contain modules or
	* interfaces.
	*/
	class IDLFile extends IDLNode {

	String filename;
	List<IDLModule> modules;
	List<IDLInterface> interfaces;

	IDLFile(this.filename, this.modules, this.interfaces);
	}

	/**
	* IDLModule has an id, and may contain interfaces, type defs and implements
	* statements.
	*/
	class IDLModule extends IDLNode {
	String id;
	List interfaces;
	List typedefs;
	List implementsStatements;

	IDLModule(String this.id, IDLExtAttrs extAttrs, IDLAnnotations annotations,
	List<IDLNode> elements) {
	setExtAttrs(extAttrs);
	this.annotations = annotations;
	this.interfaces = elements.where((e) => e is IDLInterface).toList();
	this.typedefs = elements.where((e) => e is IDLTypeDef).toList();
	this.implementsStatements =
	elements.where((e) => e is IDLImplementsStatement).toList();
	}

	toString() => '<IDLModule $id $extAttrs $annotations>';
	}

	class IDLNode {
	IDLExtAttrs extAttrs;
	IDLAnnotations annotations;
	IDLNode();

	setExtAttrs(IDLExtAttrs ea) {
	assert(ea != null);
	this.extAttrs = ea != null ? ea : new IDLExtAttrs();
	}
	}

	class IDLType extends IDLNode {
	String id;
	IDLType parameter;
	bool nullable = false;
	IDLType(String this.id, [IDLType this.parameter, bool this.nullable = false]);

	// TODO: Figure out why this constructor was failing in mysterious ways.
	// IDLType.nullable(IDLType base) {
	// return new IDLType(base.id, base.parameter, true);
	// }

	//String toString() => '<IDLType $nullable $id $parameter>';
	String toString() {
	String nullableTag = nullable ? '?' : '';
	return '<IDLType $id${parameter == null ? '' : ' $parameter'}$nullableTag>';
	}
	}

	class IDLTypeDef extends IDLNode {
	String id;
	IDLType type;
	IDLTypeDef(String this.id, IDLType this.type);

	toString() => '<IDLTypeDef $id $type>';
	}

	class IDLImplementsStatement extends IDLNode {
	}

	class IDLInterface extends IDLNode {
	String id;
	List parents;
	List operations;
	List attributes;
	List constants;
	List snippets;

	bool isSupplemental;
	bool isNoInterfaceObject;
	bool isFcSuppressed;

	IDLInterface(String this.id, IDLExtAttrs ea, IDLAnnotations ann,
	List this.parents, List members) {
	setExtAttrs(ea);
	this.annotations = ann;
	if (this.parents == null) this.parents = [];

	operations = members.where((e) => e is IDLOperation).toList();
	attributes = members.where((e) => e is IDLAttribute).toList();
	constants = members.where((e) => e is IDLConstant).toList();
	snippets = members.where((e) => e is IDLSnippet).toList();

	isSupplemental = extAttrs.has('Supplemental');
	isNoInterfaceObject = extAttrs.has('NoInterfaceObject');
	isFcSuppressed = extAttrs.has('Suppressed');
	}

	toString() => '<IDLInterface $id $extAttrs $annotations>';
	}

	class IDLMember extends IDLNode {
	String id;
	IDLType type;
	bool isFcSuppressed;

	IDLMember(String this.id, IDLType this.type, IDLExtAttrs ea, IDLAnnotations ann) {
	setExtAttrs(ea);
	this.annotations = ann;

	isFcSuppressed = extAttrs.has('Suppressed');
	}
	}

	class IDLOperation extends IDLMember {
	List arguments;

	// Ignore all forms of raises for now.
	List specials;
	bool isStringifier;

	IDLOperation(String id, IDLType type, IDLExtAttrs ea, IDLAnnotations ann,
	List this.arguments, List this.specials, bool this.isStringifier)
	: super(id, type, ea, ann) {
	}

	toString() => '<IDLOperation $type $id ${printList(arguments)}>';
	}

	class IDLAttribute extends IDLMember {
	}

	class IDLConstant extends IDLMember {
	var value;
	IDLConstant(String id, IDLType type, IDLExtAttrs ea, IDLAnnotations ann,
	var this.value)
	: super(id, type, ea, ann);
	}

	class IDLSnippet extends IDLMember {
	String text;
	IDLSnippet(IDLAnnotations ann, String this.text)
	: super(null, null, new IDLExtAttrs(), ann);
	}

	/** Maps string to something. */
	class IDLDictNode {
	Map<String, Object> map;
	IDLDictNode() {
	map = new Map<String, Object>();
	}

	setMap(List associationList) {
	if (associationList == null) return;
	for (var element in associationList) {
	var name = element[0];
	var value = element[1];
	map[name] = value;
	}
	}

	bool has(String key) => map.containsKey(key);

	formatMap() {
	if (map.isEmpty)
	return '';
	StringBuffer sb = new StringBuffer();
	map.forEach((k, v) {
	sb.add(' $k');
	if (v != null) {
	sb.add('=$v');
	}
	});
	return sb.toString();
	}

	}

	class IDLExtAttrs extends IDLDictNode {
	IDLExtAttrs([List attrs = const []]) : super() {
	setMap(attrs);
	}

	toString() => '<IDLExtAttrs${formatMap()}>';
	}

	class IDLArgument extends IDLNode {
	String id;
	IDLType type;
	bool isOptional;
	bool isIn;
	bool hasElipsis;
	IDLArgument(String this.id, IDLType this.type, IDLExtAttrs extAttrs,
	bool this.isOptional, bool this.isIn, bool this.hasElipsis) {
	setExtAttrs(extAttrs);
	}

	toString() => '<IDLArgument $id>';
	}

	class IDLAnnotations extends IDLDictNode {
	IDLAnnotations(List annotations) : super() {
	for (var annotation in annotations) {
	map[annotation.id] = annotation;
	}
	}

	toString() => '<IDLAnnotations${formatMap()}>';
	}

	class IDLAnnotation extends IDLDictNode {
	String id;
	IDLAnnotation(String this.id, List args) : super() {
	setMap(args);
	}

	toString() => '<IDLAnnotation $id${formatMap()}>';
	}

	class IDLExtAttrFunctionValue extends IDLNode {
	String name;
	List arguments;
	IDLExtAttrFunctionValue(String this.name, this.arguments);

	toString() => '<IDLExtAttrFunctionValue $name(${arguments.length})>';
	}

	class IDLParentInterface extends IDLNode {}

	////////////////////////////////////////////////////////////////////////////////

	class IDLParser {
	final int syntax;
	Grammar grammar;
	var axiom;

	IDLParser([syntax=WEBIDL_SYNTAX]) : syntax = syntax {
	grammar = new Grammar();
	axiom = _makeParser();
	}

	syntax_switch([WebIDL, WebKit, FremontCut]) {
	assert(WebIDL != null && WebKit != null); // Not options, just want names.
	if (syntax == WEBIDL_SYNTAX)
	return WebIDL;
	if (syntax == WEBKIT_SYNTAX)
	return WebKit;
	if (syntax == FREMONTCUT_SYNTAX)
	return FremontCut == null ? WebIDL : FremontCut;
	throw new Exception('unsupported IDL syntax $syntax');
	}

	_makeParser() {
	Grammar g = grammar;

	// TODO: move syntax_switch back to here.

	var idStartCharSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_';
	var idNextCharSet = idStartCharSet + '0123456789';
	var hexCharSet = '0123456789ABCDEFabcdef';

	var idStartChar = CHAR(idStartCharSet);
	var idNextChar = CHAR(idNextCharSet);

	var digit = CHAR('0123456789');

	var Id = TEXT(LEX('an identifier',[idStartChar, MANY(idNextChar, min:0)]));

	var IN = SKIP(LEX("'in'", ['in',NOT(idNextChar)]));

	var BooleanLiteral = OR(['true', 'false']);
	var IntegerLiteral = TEXT(LEX('hex-literal', OR([['0x', MANY(CHAR(hexCharSet))],
	[MANY(digit)]])));
	var FloatLiteral = TEXT(LEX('float-literal', [MANY(digit), '.', MANY(digit, min:0)]));


	var Argument = g['Argument'];
	var Module = g['Module'];
	var Member = g['Member'];
	var Interface = g['Interface'];
	var ExceptionDef = g['ExceptionDef'];
	var Type = g['Type'];
	var TypeDef = g['TypeDef'];
	var ImplStmt = g['ImplStmt'];
	var ValueTypeDef = g['ValueTypeDef'];
	var Const = g['Const'];
	var Attribute = g['Attribute'];
	var Operation = g['Operation'];
	var Snippet = g['Snippet'];
	var ExtAttrs = g['ExtAttrs'];
	var MaybeExtAttrs = g['MaybeExtAttrs'];
	var MaybeAnnotations = g['MaybeAnnotations'];
	var ParentInterfaces = g['ParentInterfaces'];


	final ScopedName = TEXT(LEX('scoped-name', MANY(CHAR(idStartCharSet + '_:.<>'))));

	final ScopedNames = MANY(ScopedName, separator:',');

	// Types

	final IntegerTypeName = OR([
	['byte', () => 'byte'],
	['int', () => 'int'],
	['long', 'long', () => 'long long'],
	['long', () => 'long'],
	['octet', () => 'octet'],
	['short', () => 'short']]);

	final IntegerType = OR([
	['unsigned', IntegerTypeName, (name) => new IDLType('unsigned $name')],
	[IntegerTypeName, (name) => new IDLType(name)]]);

	final BooleanType = ['boolean', () => new IDLType('boolean')];
	final OctetType = ['octet', () => new IDLType('octet')];
	final FloatType = ['float', () => new IDLType('float')];
	final DoubleType = ['double', () => new IDLType('double')];

	final SequenceType = ['sequence', '<', Type, '>',
	(type) => new IDLType('sequence', type)];

	final ScopedNameType = [ScopedName, (name) => new IDLType(name)];

	final NullableType =
	[OR([IntegerType, BooleanType, OctetType, FloatType,
	DoubleType, SequenceType, ScopedNameType]),
	MAYBE('?'),
	(type, nullable) =>
	nullable ? new IDLType(type.id, type.parameter, true) : type];

	final VoidType = ['void', () => new IDLType('void')];
	final AnyType = ['any', () => new IDLType('any')];
	final ObjectType = ['object', () => new IDLType('object')];

	Type.def = OR([AnyType, ObjectType, NullableType]);

	final ReturnType = OR([VoidType, Type]);

	var Definition = syntax_switch(
	WebIDL: OR([Module, Interface, ExceptionDef, TypeDef, ImplStmt,
	ValueTypeDef, Const]),
	WebKit: OR([Module, Interface]));

	var Definitions = MANY(Definition, min:0);

	Module.def = syntax_switch(
	WebIDL: [MaybeExtAttrs, 'module', Id, '{', Definitions, '}',
	SKIP(MAYBE(';')),
	(ea, id, defs) => new IDLModule(id, ea, null, defs)],
	WebKit: ['module', MaybeExtAttrs, Id, '{', Definitions, '}',
	SKIP(MAYBE(';')),
	(ea, id, defs) => new IDLModule(id, ea, null, defs)],
	FremontCut: [MaybeAnnotations, MaybeExtAttrs, 'module', Id,
	'{', Definitions, '}', SKIP(MAYBE(';')),
	(ann, ea, id, defs) => new IDLModule(id, ea, ann, defs)]);

	Interface.def = syntax_switch(
	WebIDL: [MaybeExtAttrs, 'interface', Id, MAYBE(ParentInterfaces),
	MAYBE(['{', MANY0(Member), '}']), ';',
	(ea, id, p, ms) => new IDLInterface(id, ea, null, p, ms)],
	WebKit: ['interface', MaybeExtAttrs, Id, MAYBE(ParentInterfaces),
	MAYBE(['{', MANY0(Member), '}']), ';',
	(ea, id, p, ms) => new IDLInterface(id, ea, null, p, ms)],
	FremontCut: [MaybeAnnotations, MaybeExtAttrs, 'interface',
	Id, MAYBE(ParentInterfaces),
	MAYBE(['{', MANY0(Member), '}']), ';',
	(ann, ea, id, p, ms) => new IDLInterface(id, ea, ann, p, ms)]);

	Member.def = syntax_switch(
	WebIDL: OR([Const, Attribute, Operation, ExtAttrs]),
	WebKit: OR([Const, Attribute, Operation]),
	FremontCut: OR([Const, Attribute, Operation, Snippet]));

	var InterfaceType = ScopedName;

	var ParentInterface = syntax_switch(
	WebIDL: [InterfaceType],
	WebKit: [InterfaceType],
	FremontCut: [MaybeAnnotations, InterfaceType]);

	ParentInterfaces.def = [':', MANY(ParentInterface, ',')];

	// TypeDef (Web IDL):
	TypeDef.def = ['typedef', Type, Id, ';', (type, id) => new IDLTypeDef(id, type)];

	// TypeDef (Old-school W3C IDLs)
	ValueTypeDef.def = ['valuetype', Id, Type, ';'];

	// Implements Statement (Web IDL):
	var ImplStmtImplementor = ScopedName;
	var ImplStmtImplemented = ScopedName;

	ImplStmt.def = [ImplStmtImplementor, 'implements', ImplStmtImplemented, ';'];

	var ConstExpr = OR([BooleanLiteral, IntegerLiteral, FloatLiteral]);

	Const.def = syntax_switch(
	WebIDL: [MaybeExtAttrs, 'const', Type, Id, '=', ConstExpr, ';',
	(ea, type, id, v) => new IDLConstant(id, type, ea, null, v)],
	WebKit: ['const', MaybeExtAttrs, Type, Id, '=', ConstExpr, ';',
	(ea, type, id, v) => new IDLConstant(id, type, ea, null, v)],
	FremontCut: [MaybeAnnotations, MaybeExtAttrs,
	'const', Type, Id, '=', ConstExpr, ';',
	(ann, ea, type, id, v) =>
	new IDLConstant(id, type, ea, ann, v)]);

	// Attributes

	var Stringifier = 'stringifier';
	var AttrGetter = 'getter';
	var AttrSetter = 'setter';
	var ReadOnly = 'readonly';
	var AttrGetterSetter = OR([AttrGetter, AttrSetter]);

	var GetRaises = syntax_switch(
	WebIDL: ['getraises', '(', ScopedNames, ')'],
	WebKit: ['getter', 'raises', '(', ScopedNames, ')']);

	var SetRaises = syntax_switch(
	WebIDL: ['setraises', '(', ScopedNames, ')'],
	WebKit: ['setter', 'raises', '(', ScopedNames, ')']);

	var Raises = ['raises', '(', ScopedNames, ')'];

	var AttrRaises = syntax_switch(
	WebIDL: MANY(OR([GetRaises, SetRaises])),
	WebKit: MANY(OR([GetRaises, SetRaises, Raises]), separator:','));

	Attribute.def = syntax_switch(
	WebIDL: [MaybeExtAttrs, MAYBE(Stringifier), MAYBE(ReadOnly),
	'attribute', Type, Id, MAYBE(AttrRaises), ';'],
	WebKit: [MAYBE(Stringifier), MAYBE(ReadOnly), 'attribute',
	MaybeExtAttrs, Type, Id, MAYBE(AttrRaises), ';'],
	FremontCut: [MaybeAnnotations, MaybeExtAttrs,
	MAYBE(AttrGetterSetter), MAYBE(Stringifier), MAYBE(ReadOnly),
	'attribute', Type, Id, MAYBE(AttrRaises), ';'
	]);

	// Operations

	final Special = TEXT(OR(['getter', 'setter', 'creator', 'deleter', 'caller']));
	final Specials = MANY(Special);

	final Optional = 'optional';
	final AnEllipsis = '...';

	Argument.def = syntax_switch(
	WebIDL: SEQ(MaybeExtAttrs, MAYBE(Optional), MAYBE(IN),
	MAYBE(Optional), Type, MAYBE(AnEllipsis), Id,
	(e, opt1, isin, opt2, type, el, id) =>
	new IDLArgument(id, type, e, opt1 \|\| opt2, isin, el)),

	WebKit: SEQ(MAYBE(Optional), MAYBE('in'), MAYBE(Optional),
	MaybeExtAttrs, Type, Id
	(opt1, isin, opt2, e, type, id) =>
	new IDLArgument(id, type, e, opt1 \|\| opt2, isin, false)));

	final Arguments = MANY0(Argument, ',');

	Operation.def = syntax_switch(
	WebIDL: [MaybeExtAttrs, MAYBE(Stringifier), MAYBE(Specials),
	ReturnType, MAYBE(Id), '(', Arguments, ')', MAYBE(Raises), ';',
	(ea, isStringifier, specials, type, id, args, raises) =>
	new IDLOperation(id, type, ea, null, args, specials, isStringifier)
	],
	WebKit: [MaybeExtAttrs, ReturnType, MAYBE(Id), '(', Arguments, ')',
	MAYBE(Raises), ';',
	(ea, type, id, args, raises) =>
	new IDLOperation(id, type, ea, null, args, [], false)
	],
	FremontCut: [MaybeAnnotations, MaybeExtAttrs, MAYBE(Stringifier),
	MAYBE(Specials), ReturnType, MAYBE(Id), '(', Arguments, ')',
	MAYBE(Raises), ';',
	(ann, ea, isStringifier, specials, type, id, args, raises) =>
	new IDLOperation(id, type, ea, ann, args, specials, isStringifier)
	]);

	// Exceptions

	final ExceptionField = [Type, Id, ';'];
	final ExceptionMember = OR([Const, ExceptionField, ExtAttrs]);
	ExceptionDef.def = ['exception', Id, '{', MANY0(ExceptionMember), '}', ';'];

	// ExtendedAttributes

	var ExtAttrArgList = ['(', MANY0(Argument, ','), ')'];

	var ExtAttrFunctionValue =
	[Id, '(', MANY0(Argument, ','), ')',
	(name, args) => new IDLExtAttrFunctionValue(name, args)
	];

	var ExtAttrValue = OR([ExtAttrFunctionValue,
	TEXT(LEX('value', MANY(CHAR(idNextCharSet + '&:-\|'))))]);

	var ExtAttr = [Id, MAYBE(OR([['=', ExtAttrValue], ExtAttrArgList]))];

	ExtAttrs.def = ['[', MANY(ExtAttr, ','), ']',
	(list) => new IDLExtAttrs(list)];;

	MaybeExtAttrs.def = OR(ExtAttrs,
	[ () => new IDLExtAttrs() ] );

	// Annotations - used in the FremontCut IDL grammar.

	var AnnotationArgValue = TEXT(LEX('xx', MANY(CHAR(idNextCharSet + '&:-\|'))));

	var AnnotationArg = [Id, MAYBE(['=', AnnotationArgValue])];

	var AnnotationBody = ['(', MANY0(AnnotationArg, ','), ')'];

	var Annotation = ['@', Id, MAYBE(AnnotationBody),
	(id, body) => new IDLAnnotation(id, body)];

	MaybeAnnotations.def = [MANY0(Annotation), (list) => new IDLAnnotations(list)];

	// Snippets - used in the FremontCut IDL grammar.

	final SnippetText = TEXT(LEX('snippet body', MANY0([NOT('}'), CHAR()])));
	Snippet.def = [MaybeAnnotations, 'snippet', '{', SnippetText, '}', ';',
	(ann, text) => new IDLSnippet(ann, text)];


	grammar.whitespace =
	OR([MANY(CHAR(' \t\r\n')),
	['//', MANY0([NOT(CHAR('\r\n')), CHAR()])],
	['#', MANY0([NOT(CHAR('\r\n')), CHAR()])],
	['/', MANY0([NOT('/'), CHAR()]), '*/']]);

	// Top level - at least one definition.
	return MANY(Definition);

	}
	}