On Sun, 9 Sep 2012, Jon Trulson wrote:

> How did you get this output?

On my master, being the same as the upstream
master at 1a51479e382c29a4859b16e9e1a060c06130bd2d
I have added necessary changes and commited them.

This way 87ce24fc6ae07be01dd3bf9bd1ed569433654803 was
created. Then I did:

git format-patch HEAD^ -o <my-patchdir> --start mysequencenumber

and then

git send-email <output-of-format-patch>

After it got accepted and merged, I did:

git fetch --all
git merge origin/master

and this way "git log" shows my commit (87ce24fc)
plus two extra, resulting from the merge.

> > commit 328tree a879e80682ec2d04d7130c7350c5d63b85066e98
> 
>          ^^^^^^^ ?

Sorry, I should have explained more: this is a raw 
dump of the decopressed contents of the actual git object.

I have obtained those dumps using the commands

zpipe -d < .git/objects/87/ce24fc6ae07be01dd3bf9bd1ed569433654803 
zpipe -d < .git/objects/bd/70163b09ff59331bceba9506c7cc51962571f1

I did this because SHA1 of the output of zpipe (simple
zlib decompressor, attached at the end of this email) 
becomes the official identifier of this object:

zpipe -d < .git/objects/87/ce24fc6ae07be01dd3bf9bd1ed569433654803 | sha1
87ce24fc6ae07be01dd3bf9bd1ed569433654803
zpipe -d < .git/objects/bd/70163b09ff59331bceba9506c7cc51962571f1 | sha1
bd70163b09ff59331bceba9506c7cc51962571f1

Internal format of git object contains of the object type
(here 'commit') written in ASCII followed by space and the length
of the rest of the object (here 328) and a '\0'. Then you have
a word "tree" and SHA-1 of the tree (state of files). It is
the same in case of those two commits, which means those commits
result in the same contents of all files and directories.

> Is it possible that you are seeing two commits - the one I applied to
> master, and the one you applied to your dev branch?

Yes, both ended up in my master (one because I committed it,
the other because I imported what was applied).

> I just do not know what the issue is - I haven't done anything
> different - aside from creating a tag before your commit.  Not sure
> why that would affect anything here.

I try to understand why my commit gets changed after it is included
in master. Most probably my understanding of the email workflow
is inadequate.

> The the need to merge (hence the 'merge' commits) will always happen.
> But I have not heard of this particular problem before.
> 
> To be clear, a 'git log' shows this commit twice?  And this is while
> you are on a checked out master?

"git log" shows two commits with the same description 
- you can see it here:

http://sourceforge.net/u/saperski/cde-freebsd/ci/1e4e442df186df4e5319f7bd31b4e8e217dec49a/log/

What I will do from now on - always work on a different branch
out of master and commit my changes there. This way my master
will stay clean (the exact copy of the official repository).

Below is the source of zpipe, needs to be compiled against zlib
(cc -o zpipe zpipe.c -lz on most systems).

//Marcin

/* zpipe.c: example of proper use of zlib's inflate() and deflate()
   Not copyrighted -- provided to the public domain
   Version 1.2  9 November 2004  Mark Adler */

/* Version history:
   1.0  30 Oct 2004  First version
   1.1   8 Nov 2004  Add void casting for unused return values
                     Use switch statement for inflate() return values
   1.2   9 Nov 2004  Add assertions to document zlib guarantees
   1.3   6 Apr 2005  Remove incorrect assertion in inf()
 */

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "zlib.h"

#define CHUNK 16384

/* Compress from file source to file dest until EOF on source.
   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_STREAM_ERROR if an invalid compression
   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
   version of the library linked do not match, or Z_ERRNO if there is
   an error reading or writing the files. */
int def(FILE *source, FILE *dest, int level)
{
    int ret, flush;
    unsigned have;
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];

    /* allocate deflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit(&strm, level);
    if (ret != Z_OK)
        return ret;

    /* compress until end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)deflateEnd(&strm);
            return Z_ERRNO;
        }
        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = in;

        /* run deflate() on input until output buffer not full, finish
           compression if all of source has been read in */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = deflate(&strm, flush);    /* no bad return value */
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)deflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);
        assert(strm.avail_in == 0);     /* all input will be used */

        /* done when last data in file processed */
    } while (flush != Z_FINISH);
    assert(ret == Z_STREAM_END);        /* stream will be complete */

    /* clean up and return */
    (void)deflateEnd(&strm);
    return Z_OK;
}

/* Decompress from file source to file dest until stream ends or EOF.
   inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_DATA_ERROR if the deflate data is
   invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
   the version of the library linked do not match, or Z_ERRNO if there
   is an error reading or writing the files. */
int inf(FILE *source, FILE *dest)
{
    int ret;
    unsigned have;
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];

    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit(&strm);
    if (ret != Z_OK)
        return ret;

    /* decompress until deflate stream ends or end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)inflateEnd(&strm);
            return Z_ERRNO;
        }
        if (strm.avail_in == 0)
            break;
        strm.next_in = in;

        /* run inflate() on input until output buffer not full */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = inflate(&strm, Z_NO_FLUSH);
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            switch (ret) {
            case Z_NEED_DICT:
                ret = Z_DATA_ERROR;     /* and fall through */
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void)inflateEnd(&strm);
                return ret;
            }
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)inflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);

        /* done when inflate() says it's done */
    } while (ret != Z_STREAM_END);

    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
}

/* report a zlib or i/o error */
void zerr(int ret)
{
    fputs("zpipe: ", stderr);
    switch (ret) {
    case Z_ERRNO:
        if (ferror(stdin))
            fputs("error reading stdin\n", stderr);
        if (ferror(stdout))
            fputs("error writing stdout\n", stderr);
        break;
    case Z_STREAM_ERROR:
        fputs("invalid compression level\n", stderr);
        break;
    case Z_DATA_ERROR:
        fputs("invalid or incomplete deflate data\n", stderr);
        break;
    case Z_MEM_ERROR:
        fputs("out of memory\n", stderr);
        break;
    case Z_VERSION_ERROR:
        fputs("zlib version mismatch!\n", stderr);
    }
}

/* compress or decompress from stdin to stdout */
int main(int argc, char **argv)
{
    int ret;

    /* do compression if no arguments */
    if (argc == 1) {
        ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }

    /* do decompression if -d specified */
    else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
        ret = inf(stdin, stdout);
        if (ret != Z_OK)
            zerr(ret);
        return ret;
    }

    /* otherwise, report usage */
    else {
        fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
        return 1;
    }
}

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
cdesktopenv-devel mailing list
cdesktopenv-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/cdesktopenv-devel

Reply via email to