scripts.idlnode Namespace Reference

Classes
class	IDLAnnotation
class	IDLAnnotations
class	IDLArgument
class	IDLAttribute
class	IDLCallbackFunction
class	IDLConstant
class	IDLDictionary
class	IDLDictionaryMember
class	IDLDictionaryMembers
class	IDLDictNode
class	IDLEnum
class	IDLExtAttrFunctionValue
class	IDLExtAttrs
class	IDLFile
class	IDLImplementsStatement
class	IDLInterface
class	IDLMember
class	IDLModule
class	IDLNode
class	IDLOperation
class	IDLParentInterface
class	IDLType
class	IDLTypeDef

Functions
def	report_unions_to_any ()
def	resolveTypedef (type)
def	generate_callback (interface_name, result_type, arguments)
def	generate_operation (interface_name, result_type_name, oper_name, arguments, result_nullable=False)
def	generate_setLike_operations_properties (interface, set_like)

Variables
dictionary	new_asts = {}

Function Documentation

generate_callback()

def scripts.idlnode.generate_callback	(		interface_name,
			result_type,
			arguments
	)

Definition at line 826 of file idlnode.py.

def generate_callback(interface_name, result_type, arguments):
    syn_op = IDLOperation(None, interface_name, 'callback')
 
    syn_op.type = resolveTypedef(result_type)
    syn_op.arguments = arguments
 
    return syn_op
 
 

generate_operation()

def scripts.idlnode.generate_operation	(		interface_name,
			result_type_name,
			oper_name,
			arguments,
			result_nullable = False
	)

 Synthesize an IDLOperation with no AST used for support of setlike.

 Arguments is a list of argument where each argument is:
      [IDLType, argument_name, optional_boolean] 

Definition at line 835 of file idlnode.py.

                       result_nullable=False):
    """ Synthesize an IDLOperation with no AST used for support of setlike."""
    """ Arguments is a list of argument where each argument is:
          [IDLType, argument_name, optional_boolean] """
 
    syn_op = IDLOperation(None, interface_name, oper_name)
 
    syn_op.type = IDLType(None, result_type_name)
    syn_op.type = resolveTypedef(syn_op.type)
    syn_op.type.nullable = result_nullable
 
    for argument in arguments:
        arg = IDLArgument(None, argument[1])
        arg.type = argument[0]
        arg.optional = argument[2] if len(argument) > 2 else False
        syn_op.arguments.append(arg)
 
    return syn_op
 
 

generate_setLike_operations_properties()

def scripts.idlnode.generate_setLike_operations_properties	(		interface,
			set_like
	)

Need to create (in our database) a number of operations.  This is a new IDL
syntax, the implied operations for a set now use setlike<T> where T is a known
type e.g., setlike<FontFace> setlike implies these operations are generated:

   void forEach(any callback, optional any thisArg);
   boolean has(FontFace fontFace);
   boolean has(FontFace fontFace);

if setlike is not read-only these operations are generated:

       FontFaceSet add(FontFace value);
       boolean delete(FontFace value);
       void clear();

Definition at line 859 of file idlnode.py.

def generate_setLike_operations_properties(interface, set_like):
    """
  Need to create (in our database) a number of operations.  This is a new IDL
  syntax, the implied operations for a set now use setlike<T> where T is a known
  type e.g., setlike<FontFace> setlike implies these operations are generated:
 
       void forEach(any callback, optional any thisArg);
       boolean has(FontFace fontFace);
       boolean has(FontFace fontFace);
 
  if setlike is not read-only these operations are generated:
 
           FontFaceSet add(FontFace value);
           boolean delete(FontFace value);
           void clear();
  """
    setlike_ops = []
    """
  Need to create a typedef for a function callback e.g.,
  a setlike will need a callback that has the proper args in FontFaceSet that is
  three arguments, etc.
 
      typedef void FontFaceSetForEachCallback(
        FontFace fontFace, FontFace fontFaceAgain, FontFaceSet set);
 
      void forEach(FontFaceSetForEachCallback callback, [Object thisArg]);
  """
    callback_name = '%sForEachCallback' % interface.id
    set_op = generate_operation(interface.id, 'void', 'forEach',
                                [[IDLType(None, callback_name), 'callback'],
                                 [IDLType(None, 'any'), 'thisArg', True]])
    setlike_ops.append(set_op)
 
    set_op = generate_operation(
        interface.id, 'boolean', 'has',
        [[IDLType(None, set_like.value_type.base_type), 'arg']])
    setlike_ops.append(set_op)
 
    if not set_like.is_read_only:
        # Issue #45676: `add` can return null on Firefox, so this should be
        # typed nullable.
        add_result_nullable = True
        set_op = generate_operation(
            interface.id, interface.id, 'add',
            [[IDLType(None, set_like.value_type.base_type), 'arg']],
            add_result_nullable)
        setlike_ops.append(set_op)
        set_op = generate_operation(
            interface.id, 'boolean', 'delete',
            [[IDLType(None, set_like.value_type.base_type), 'arg']])
        setlike_ops.append(set_op)
        set_op = generate_operation(interface.id, 'void', 'clear', [])
        setlike_ops.append(set_op)
 
    return setlike_ops
 
 

report_unions_to_any()

def scripts.idlnode.report_unions_to_any

(

)

Definition at line 20 of file idlnode.py.

def report_unions_to_any():
    global _unions_to_any
 
    warnings = []
    for union_id in sorted(_unions_to_any):
        warnings.append('Union type %s is mapped to \'any\'' % union_id)
 
    return warnings
 
 
# Ugly but Chrome IDLs can reference typedefs in any IDL w/o an include.  So we
# need to remember any typedef seen then alias any reference to a typedef.

resolveTypedef()

def scripts.idlnode.resolveTypedef

(

type

)

 Given a type if it's a known typedef (only typedef's that aren't union)
  are remembered for fixup.  typedefs that are union type are mapped to
  any so those we don't need to alias.  typedefs referenced in the file
  where the typedef was defined are automatically aliased to the real type.
  This resolves typedef where the declaration is in another IDL file.

Definition at line 39 of file idlnode.py.

def resolveTypedef(type):
    """ Given a type if it's a known typedef (only typedef's that aren't union)
      are remembered for fixup.  typedefs that are union type are mapped to
      any so those we don't need to alias.  typedefs referenced in the file
      where the typedef was defined are automatically aliased to the real type.
      This resolves typedef where the declaration is in another IDL file.
  """
    for typedef in _typeDefsFixup:
        if typedef.id == type.id:
            return typedef.type
 
    return type
 
 

Variable Documentation

new_asts

dictionary scripts.idlnode.new_asts = {}

Definition at line 14 of file idlnode.py.