def marshal( compoundSignature, variableList, startByte = 0, lendian=True ):
    """
    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)
    """
    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