code: def marshal( compoundSignature, variableList, startByte = 0, lendian=True ):
      
      chunks = list()
      bstart = startByte
  
      if hasattr(variableList, 'dbusOrder'):
          order = getattr(variableList, 'dbusOrder')
          variableList = [ getattr(variableList, attr_name) for attr_name in order ]
  
      for ct, var in zip(genCompleteTypes( compoundSignature ), variableList):
          tcode   = ct[0]
          padding = pad[tcode]( startByte )
          
          if padding:
              startByte += len(padding)
              chunks.append( padding )
          
          nbytes, vchunks = marshallers[ tcode ]( ct, var, startByte, lendian )
  
          startByte += nbytes
          
          chunks.extend( vchunks )
          
  
      return startByte - bstart, chunks
docs: Encodes the Python objects in variableList into the DBus wire-format
      matching the supplied compoundSignature. This function retuns a list of
      binary strings is rather than a single string to simplify the recursive
      marshalling algorithm. A single string may be easily obtained from the
      result via: ''.join(list_of_binary_strings)
      
      @type compoundSignature: C{string}
      @param compoundSignature: DBus signature specifying the types of the
                                variables to encode
  
      @type variableList: C{list}
      @param variableList: List of variables to encode (length of the list
                           must exactly match the number of variables specified
                           in compoundSignature
  
  
      @type startByte: C{int}
      @param startByte: Used during recursive marshalling to ensure data
                        alignment requirements are met
  
      @type lendian: C{bool}
      @param lendian: True if the data should be serialized in
                      little-endian format
  
      
      @returns: (number_of_encoded_bytes, list_of_binary_strings)