#!/usr/bin/env python
#regdiff.py
#Created November 9 2008
#Updated November 10 2008
#Version 0.3.1

#This program is free software; you can redistribute it and/or modify it under
#the terms of the GNU General Public License version 2, the GNU Free
#Documentation License version 1.2 (with no Invariant Sections, with no
#Front-Cover Texts, and with no Back-Cover Texts), or (at your option) any
#later version of either license.  It is distributed in the hope that it will
#be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
#Public License for more details.

#Description:
#Compares two Windows registry (.REG) files and produces a third such that
#applying it transforms a registry represented by the first into a registry
#represented by the second.  Usually you should redirect the output to a file.

#Set displayProgress to a positive value n to report with a # every n lines.

#Warnings:
#The output deletes all keys and values present in the first but not in the
#second!  Therefore, this should be run only on exports of complete subtrees.

#The input must be sorted (values sorted within each key); I believe that
#Regedit's export does this, and will also guarantee complete subtrees.

#It's probably wise to double check any key removals in the output: look for
#lines beginning with the two characters "[-".  Modern .REG files use UTF-16,
#so some editors and tools (like grep) may have trouble with them.  Using
#"grep '^.\[.-' out.reg" should work to at least detect removals.

#You can disable deletions of keys or values entirely by setting the
#appropriate variables (allow*Delete).  If keys cannot be deleted but values
#can, each value named in the old file under a key that would be deleted will
#be deleted.  (This is not as dangerous because reapplying the old file will
#restore them.)

#History:
#Version 0.1, November 9 2008:
# - initial release
#Version 0.2, November 9 2008:
# - use CRLF newlines
# - support deletion disabling
# - detect misorderings
#Version 0.3, November 9 2008:
# - make allowKeyDelete apply to the last keys to delete
# - verify continuous progress
# - support displaying progress
#Version 0.3.1, November 10 2008:
# - use case-insensitive and subkey-aware comparisons for ordering

#Bugs:
#Assumes that no key contains assignments to @ and to "" -- I think the latter
#is invalid anyway.

#I don't know whether .REG files are really UTF-16 or UCS-2.

#I'm not sure that the last blank line is really necessary; a trailing CRLF
#may be sufficient.

import sys,codecs

def keycompare(a,b):
    """Return an integer indicating the ordering of keys a and b."""
    return cmp(a.lower().split('\\'),b.lower().split('\\'))

class line(object):
    def __init__(self,s,k=None):
        """Parse s and make a line object.
Inherit key from line k unless we are a key or it is omitted or None.
Use k to detect misordered input if it is not None.
Names are not unescaped, but escaping is considered in their extent."""
        self.old=False
        self.str=s
        self.eof=s is None
        self.iskey=not self.eof and len(s)>1 and s[0]=='['
        index=1                 # points past end of name
        if self.eof:
            self.name=None
            self.delete=False
            self.lastkey=None
        elif self.iskey:
            self.delete=s[1]=='-'
            self.lastkey=self.name=s[1+self.delete:-3] # ends in "]\r\n"
            if k is not None and k.lastkey is not None and\
                    keycompare(self.lastkey,k.lastkey)<0:
                raise ValueError,"key %r precedes %r in input"%\
                    (k.lastkey,self.lastkey)
        else:
            if s[0]=='"':
                quote=False
                for c in s[1:]:
                    index+=1
                    if quote: quote=False
                    elif c=='\\': quote=True
                    elif c=='"': break
                else: raise IOError,"unterminated name in "+repr(s)
            elif s[0]!='@': raise IOError,"unrecognized format: "+repr(s)
            # The name for @ is "", which properly sorts before everything.
            self.name=s[1:index-1]
            assign=s[index:].lstrip()
            if len(assign)<2 or assign[0]!='=':
                raise IOError,"no assignment in" +repr(s)
            self.delete=assign[1]=='-'
            if k is None:
                self.lastkey=None
            else:
                self.lastkey=k.lastkey
                if not k.iskey and self.name.lower()<k.name.lower():
                    raise ValueError,"value %r precedes %r in input"%\
                        (k.name,self.name)

    def valname(self):
        """Return the original form of this value's name."""
        if self.iskey: raise ValueError,"this is not a value"
        return '"'+self.name+'"' if self.name else '@'

    def __str__(self):
        return self.__class__.__name__+\
            ('['+("EOF" if self.eof else
                  repr(self.str)+(" (key)" if self.iskey else
                                  " in key "+repr(self.lastkey)))+
             ": "+repr(self.name)+']')

class keyprint(object):
    def __init__(self,o):
        self.key=None
        self.out=o
    def __call__(self,k):
        if k!=self.key:
            self.key=k
            self.out.write("\r\n["+k+"]\r\n")

def terminated(s):
    """Return true if the string contains an even number of unquoted \"s and does
not end in an unescaped backslash."""
    quote=False
    ret=True
    for c in s:
        if quote: quote=False
        elif c=='\\': quote=True
        elif c=='"': ret=not ret
    return ret and not quote

def nextLogical(f):
    """Return the next logical line from a file object.
Never returns a null string.
Return None at EOF."""
    ret=""
    done=False
    while not done:
        l=f.readline()
        if l=="":
            if ret=="": return None
            else: raise IOError,"file ends with escape or in string"
        c=l.rstrip('\r\n')
        if c=="" and ret=="": continue # skip initial blank lines
        ret+=c
        done=terminated(ret)
        if c!=l: ret+="\r\n"
    return ret

def isunder(s,r):
    """Return non-nil if the key s is in the tree rooted at r."""
    return s==r or s.startswith(r+'\\');

if len(sys.argv)!=3:
    print >>sys.stderr,"usage: "+sys.argv[0]+" old.reg new.reg"
    sys.exit(2)                 # BAD_ARGS

allowKeyDelete=True
allowValueDelete=True
displayProgress=0
ci=codecs.lookup("utf_16")
fo=ci.streamreader(open(sys.argv[1],'rb'))
fn=ci.streamreader(open(sys.argv[2],'rb'))
out=ci.streamwriter(sys.stdout)
kp=keyprint(out)
head=fo.readline()
if fn.readline()!=head:
    raise IOError,"different file headers"
out.write(head.rstrip('\r\n')+"\r\n")

o=n=line(None)
o.old=True
killing=False                   # the tree being deleted, if any
iters=0
while True:
    iters+=1
    if displayProgress and iters%displayProgress==0:
        sys.stderr.write('#')

    if o.old: o=line(nextLogical(fo),o)
    if n.old: n=line(nextLogical(fn),n)

    if o.eof and n.eof: break
    if o.delete or n.delete: raise IOError,"input contains deletion requests"

    # Determine which line logically comes first; all keys come after all
    # values (since the values go with a previous key), and EOF comes after
    # everything.  Positive values mean that n comes first.
    c=o.eof-n.eof or keycompare(o.lastkey,n.lastkey) or\
        o.iskey-n.iskey or cmp(o.name.lower(),n.name.lower())
    o.old=c<=0
    n.old=c>=0
    assert o.old or n.old,"not advancing in the file"

    if killing and (o.eof or not isunder(o.lastkey,killing)): killing=False

    if not killing:
        if c<0:
            if o.iskey:
                # Delete a whole key if the new file is past all its subkeys.
                # Note that n.lastkey!=o.name, because n must be a key.
                if (n.eof or not isunder(n.lastkey,o.name)) and allowKeyDelete:
                    killing=o.name
                    out.write("\r\n[-"+o.name+"]\r\n")
            elif allowValueDelete:
                kp(o.lastkey)
                out.write(o.valname()+"=-\r\n")
        elif not n.iskey and n.str!=o.str:
            kp(n.lastkey)
            out.write(n.str)

out.write("\r\n")
if displayProgress: sys.stderr.write('\n')