博客园_海阔凭鱼跃，天高任鸟飞

使用Python和vim插件结合让Vim支持多文件夹比较

2012-02-07T14:52:00Z

在Vim的官方网站上有一个支持2个文件夹比较的插件DirDiff, 链接: http://www.vim.org/scripts/script.php?script_id=102. 不过仅支持2个文件夹, 我对齐进行研究并改进后让其支持多个文件夹的文件进行比较.

DirDiff插件的基本原理就是先生成要比较的几个文件夹中的所有文件列表文件, 该文件的每一行对应于一个文件以及它所在的文件夹. 启用文件夹比较模式时, 会载入这个列表文件, 当选中一行时会解析出文件路径, 然后以diff模式分别打开这个文件在不同文件夹下对应的文件进行比较.

这里为了方便, 我就使用Python来生成这个特定格式的文件列表, 然后启动vim 并启动文件夹插件比较.

Python脚本如下:

1 #!/usr/bin/env python
2 # coding:UTF-8
3
4 import os,sys,shutil,subprocess
5 from os import path
6 # 将dirlist中的目录列表下的文件放在一个文件词典filesdict中,
7 # 词典的key是dirlist中某个目录下的文件名(不含该目录名),
8 # value是dirlist中存在对应的key的所有目录
9 def getfilesfromdirs(dirlist):
10 filesdict = {}
11 for onedir in dirlist:
12 onedir = path.realpath(onedir) # 规范化目录名
13 #处理目标路径下(含子目录下)的所有文件
14 for root,dirs,files in os.walk(onedir):
15 # 记录每个文件名所属的目录,同名文件则会属于多个不同目录.
16 # 这样就生成了文件名到文件所在目录的倒排索引
17 for onefile in files:
18 # 若该文件名的键值还未创建则先创建
19 onefile = os.path.join(root,onefile)[len(onedir):]
20 if onefile not in filesdict:
21 filesdict[onefile] = []
22 filesdict[onefile] += [onedir]
23 return filesdict
24
25 def vimDirDiffN(diffdirs):
26 diffbuffer = './vimdirdiffntmpbuffer'
27 filesdict = getfilesfromdirs(diffdirs)
28 fileslines = []
29 for key,values in filesdict.iteritems():
30 fileslines += [' File: '+key+' @ ' + ','.join(values)]
31 write2fileline = str(len(diffdirs))
32 fileslines = '\n'.join(fileslines)
33 dirsymbol = 'A'
34 for onedir in diffdirs:
35 dirline = '<' + dirsymbol + '>' + '=' + onedir
36 write2fileline += '\n' + dirline
37 fileslines = fileslines.replace(onedir,'<' + dirsymbol + '>')
38 dirsymbol = chr(ord(dirsymbol) + 1)
39 write2fileline += '\n\n' + fileslines
40 fp = open(diffbuffer,'w')
41 fp.write(write2fileline)
42 fp.close()
43 subprocess.Popen('gvim -c ":DirDiffN ' + path.join(os.getcwd(),diffbuffer) + '"',shell=True)
44
45 if __name__ == "__main__":
46 if len(sys.argv) > 2:
47 diffdirs = sys.argv[1:]
48 for index in range(0,len(diffdirs)):
49 diffdirs[index] = path.realpath(diffdirs[index])
50 vimDirDiffN(diffdirs)
51 else:
52 print "Interactive Mode."
53 diffdirs = raw_input('input the dirs you want to diff(in List["A","B"]): ')
54 if diffdirs == '':
55 diffdirs = ['f:/PYOutput/old','f:/PYOutput/new','f:/PYOutput/third_merge']
56 else:
57 diffdirs = eval(diffdirs)
58 for index in range(0,len(diffdirs)):
59 diffdirs[index] = path.realpath(diffdirs[index])
60 vimDirDiffN(diffdirs)
61 raw_input('press to exit.')

这个脚本就是读入用户输入需要比较的文件夹列表, 然后扫描文件生成一个比较列表, 启动vim并执行我修改后的多文件夹比较插件DirDiffN.

修改后的DirDiffN插件比较多, 可以从附件下载. DirDiffN插件下载

将DirDiffN放入Vim的插件目录下即可.

效果预览图:

本文链接

Ｗindows安全机制

2011-05-28T16:53:00Z

最近研究了点关于Ｗindows安全机制以及COM的 Reg-Free方案。研究的原因是试图构造一个安全的第三方插件的沙箱环境，而第三方插件是实现为COM组件的，因此又涉及到在受限环境下的COM调用的问题，为了解决受限环境的COM注册问题引入了Reg-Free的方案。

整个插件环境是和主程序隔离的，每个插件都使用一个独立进程，插件的宿主进程是一个进程外的COM组件，主进程启动宿主进程后，有宿主进程负责创建相应的插件对象，插件被创建起来后就在宿主进程中运行。为了保证插件不影响用户的系统，需要在宿主进程创建插件对象之前将宿主进程放进一个受限的沙箱环境中。

Ｗindows的安全模型主要由2个部分组成，一个是用于授权的Ａccess Ｔoken，一个是用于保护安全对象的Ｓecurity Ｄescriptor。一个进程访问某个安全对象时，系统会使用对象的
Ｓecurity Ｄescriptor检查当前进程的Ｔoken是否有权限访问该对象。
Ａccess Ｔoken包含了一些SID用于标示它拥有的安全身份，另外还包含一些Ｐrivilege信息以及其他授权信息。
Ｓecurity Ｄescriptor包含了用于控制访问权限的DACL列表以及用于审核的SACL列表。ACL列表是一系列的ACE信息，每个ACE包含了某个SID的访问权限，当一个进程访问一个对象时，系统会逐个检查对象的ACE项，如果该进程的Ｔoken中包含的SID匹配ACE中的SID,那么系统就会执行ACE中对该SID的访问控制操作（拒绝或者允许），需要注意的是系统是按照列表从头到尾的顺序逐个检测ACE,一旦有拒绝或者允许的匹配项，都会立刻停止检测后继的ACE项。（除非token中有指定ＲestrictedSID）.

下图是2个不同线程访问一个安全对象的过程：

关于Ｗindows安全机制，它提供了几种机制来确保安全性，主要有ＲestrictedToken，Ｊob Object，Ａlternate Ｄesktop，以及在Ｖista引入的IntegrityLevel的方案来简化和加强
Ｗindows下的安全隔离。

对于ＲestrictedToken可以使用ＣreateＲestrictedToke函数创建一个受限的Ｔoken，然后使用ＣreateProcessAsUser以受限的token来启动受限进程。而Ｊob可以限制一个进程使用的系统资源，比如CPU使用率，内存使用率，活动进程，剪切版的使用等，在XP下还可以给Ｊob设置安全token来设置job的安全属性（Ｖista以上不支持job的安全属性了）。Ｖista以后引入的IntegrityLevel有四个级别分别为Ｌow, Medium, High, System，低级别的属性不能访问具有高级别的对象，默认所有安全对象都是Ｍedium级别的。另外IntegrityLevel还对注册表的访问和文件的操作做了一些重定向的处理，以保证程序的兼容性。特别是COM调用相关的一些处理，使得即使在最低的级别下一些COM的调用仍然能成功。
由于XP,和XP以上的系统在安全机制上的一些区别，不得不做2种不同的处理。在XP系统下，主要使用Job以及其安全属性，使用JOBOBJECT_EXTENDED_LIMIT_INFORMATION, JOBOBJECT_BASIC_UI_RESTRICTIONS以及JOBOBJECT_SECURITY_LIMIT_INFORMATION设置一个受限的JOB并将进程放入该Job中，同时还要使用AdjustTokenPrivileges将进程的一些Ｐrivilege信息删除。而在Ｖista以后的系统中，无法使用JOBOBJECT_SECURITY_LIMIT_INFORMATION设置Job的安全属性，改用IntegrityLevel将进程的安全级别设置为Ｌow。

在上述的受限环境中，进程的写权限几乎被完全禁止了（除了设定为较低安全级别的对象），仅剩下读权限，这样基本能防止插件对系统造成损害了。
当然，在这种受限环境下,经过测试，XP系统下的COM进程间通信会有一些问题，而Ｖista下的IntegrityLevel似乎对这种情况专门做了处理，因此发现vista下在受限环境下的COM进程间通信一切顺利。为了处理XP下在受限环境下的COM调用和注册，引入一种COM的免注册方案，即Registration-Free 技术。主要就是利用manifest文件让COM的注册脱离注册表依赖。关于Ｒeg-Ｆree技术参考文献有2篇文章写的已经很详细了。需要注意的是，XP和Ｖista之后的manifest文件的都去顺序问题，XP系统是先尝试读取外部manifest文件，没找到才尝试读取dll文件本身嵌入的manifest资源，而vista之后刚好反过来了。另外，进程外的COM组件是不支持Ｒeg-Ｆree的。(经测试，XP下使用reg-free的方案好像只能解决COM进程内的接口调用，对于进程间的接口调用还得另做处理。)

最后，还有一个需要注意的是Ｗin7下的Ｊob处理，由于Ｗin7下的explorer进程会将进程放入一个PCA的Ｊob中，为了避免使用我们自己的Ｊob失败，我们需要防止Ｗin7的这种自作主张的行为，需要在manifest文件中加入以下内容，
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
<v3:trustInfo xmlns:v3="urn:schemas-microsoft-com:asm.v3">
<v3:security>
<v3:requestedPrivileges>
<v3:requestedExecutionLevel level="asInvoker" uiAccess="false" />
</v3:requestedPrivileges>
</v3:security>
</v3:trustInfo>
<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>

<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>

<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
</application>
</compatibility>
</assembly>

关于Ｗindows安全方面更多详细的资料可以查看以下参考文献。
参考文献：
http://msdn.microsoft.com/en-us/library/aa379570(v=vs.85).aspx

http://www.tenouk.com/ModuleH.html

http://msdn.microsoft.com/en-us/library/aa480244.aspx

http://www.google.co.uk/patents/about?id=m40IAAAAEBAJ

about COM Reg-Free,
http://blogs.msdn.com/b/junfeng/archive/2006/05/17/registration-free-com-net-interop.aspx
http://msdn.microsoft.com/en-us/library/ms973913.aspx
http://msdn.microsoft.com/en-us/magazine/cc188708.aspx

本文链接

使用某个文件夹下的所有文件去替换另一个文件夹下及其子文件夹下存在的同名文件(Python实现)

2010-12-31T11:48:00Z

值此新年即将到来之际,在这献上今年最后一篇文章.

产生这个需求是在项目的一次图标替换上,当时给了我一堆新图标要替换原来的老图标,可是原来的老图标分布在某个文件夹下的各个子文件夹下面,而新图标全是在同一个目录下的. 手动替换的话,只能是搜索文件名后替换,但是文件很多太麻烦了,没找到现成的工具可以实现我的需求.于是有了下面这个脚本,正好熟悉下刚刚学会的Python. 如果有人知道有什么工具可以完成的话不妨留言告知:).

下面脚本实现的就是在dest目录及其子目录下面,寻找和src目录下的文件对应的同名文件,如果找到唯一的一个同名文件,用src里面的新文件替换dest里面对应的老文件. 如果没找到同名或有多个同名的,就忽略.因为这种情况下需要人工接入是否替换,不过这样工作量已经少了很多了.

代码通过扫描一遍dest目录及其子目录,建立了以文件名为索引,文件所在目录名为键值的倒排索引. 然后对src目录下的每个文件名去刚刚建立的倒排索引中寻找键值,如果键值中刚好只有一个目录名,说明找到了对应的唯一同名文件,替换之.其他的忽略.

代码如下:

#!/usr/bin/env python
# coding:UTF-8

import os,sys,shutil
from os import path

def findandreplace(src,dest):
srcfiles = os.listdir(src)
destfilesdict = {}
#处理目标路径下(含子目录下)的所有文件
for root,dirs,files in os.walk(dest):
# 记录每个文件名所在的路径,多个同名文件则会有多个不同路径.
# 这样就生成了文件名到文件所在路径的一个倒排索引
for onefile in files:
# 若该文件名的键值还未创建则先创建
if onefile not in destfilesdict:
destfilesdict[onefile] = []
destfilesdict[onefile] += [root]
multisamename = []; # 存储目标目录及其子目录下有多个同名文件的文件名
for srcfile in srcfiles:
fullsrcfile = os.path.join(src,srcfile)
if os.path.isfile(fullsrcfile):
if srcfile in destfilesdict:
if len(destfilesdict[srcfile])>1:
multisamename += [srcfile]
else:
# 有且只有唯一的一个同名文件,那么肯定是要替换的那个
shutil.copy(fullsrcfile,destfilesdict[srcfile][0]+'/'+srcfile)
print srcfile + ' replace success.'
print 'following files has more than one in dest directory, replace skipped.'
print '\n'.join(multisamename);

if __name__ == "__main__":
args = sys.argv
if len(args) > 2:
src = args[1]
dest = args[2]
print "all files under the "+dest+\
"(including the subdirectory) will be replaced by the files under " +\
src+" where they have the same name."
if raw_input('Sure(y/n?): ') == 'y':
findandreplace(src,dest)
else:
print "Not enough arguments!"

测试代码如下:

#!/usr/bin/env python
# coding:UTF-8

import os,sys
import shutil
import findandreplace

rootdir = 'd:/test/'
testsrcdir = 'testsrc'
testdestdir = 'testdest'
testfile = { 'notexist' : ['001','002','003','004','005'], # 替换目标不存在的文件
'onlyone' : ['101','102','103','104','105'], # 有唯一对应的文件存在的
'morethanone':['201','202','203','204','205']} # 多于一个同名存在的
testfileext = '.txt'
# clear old test files
shutil.rmtree(os.path.join(rootdir,testsrcdir),True)
shutil.rmtree(os.path.join(rootdir,testdestdir),True)
# generate src files
os.makedirs(os.path.join(rootdir,testsrcdir))
for key,values in testfile.iteritems():
for filestr in values:
srcfile = open(os.path.join(rootdir,testsrcdir,filestr+testfileext),'w')
srcfile.write(filestr+'srcfile')
srcfile.close()
# generate dest files
os.makedirs(os.path.join(rootdir,testdestdir))
for key,values in testfile.iteritems():
if key == 'notexist':
pass
elif key == 'onlyone':
for filestr in values:
newdir = os.path.join(rootdir,testdestdir,filestr)
os.makedirs(newdir)
srcfile = open(os.path.join(newdir,filestr+testfileext),'w')
srcfile.write(filestr+'destfile')
srcfile.close()
elif key=='morethanone':
for filestr in values:
newdir = os.path.join(rootdir,testdestdir,filestr)
os.makedirs(newdir)
srcfile = open(os.path.join(newdir,filestr+testfileext),'w')
srcfile.write(filestr+'destfile')
srcfile.close()
srcfile = open(os.path.join(rootdir,testdestdir,filestr+testfileext),'w')
srcfile.write(filestr+'destfile')
srcfile.close()

findandreplace.findandreplace(os.path.join(rootdir,testsrcdir),os.path.join(rootdir,testdestdir))

Python真是提高效率的利器哈.

本文链接

用python实现一个按需生成用于vim跳转的tags文件的小程序

2010-12-04T14:57:00Z

初学python，找个有用的来练手。选定了一个我早就想做的让vim按需生成tags跳转文件的小程序。

vim的tags用于跳转的好处自是不用多说，但是如何生成tags确实困扰我的一大问题，用VS的都知道，VS会为每个解决方案生成一个ncb文件用于自动提示，相当于tags的功能，这个ncb文件很智能，它会根据你所包含的头文件来自动处理。这样，你只需包含一个头文件，就可以出现该头文件相关的自动提示了。

但是vim就没有像VS这么智能了，目前我的做法就是在某个目录下调用ctags，然后加上递归参数，这样的缺点就是会生成一个很大的tags文件，里面很多都是项目根本没用到的头文件的tags。为了改善这种情况，需要有一个按所用到的头文件来生成tags的方法，让ctags按需生成tags。

ctags本身是支持从一个文件中读入需要生成tags的文件列表的，因此剩下的问题就是如何找到项目所用到的所有相关的C++文件，然后让ctags从这些文件中生成tags。这就是我拿来练手的小程序了。

python的好处就是不用像C++那样考虑那么多不相关的细节，专注于你想做的。代码如下，应该还算精简吧。有更好的方法不妨评论分享下，:)

# -*- coding: utf8 -*- # by absolute8511 2010-12-04import os,sys
from os import path
import string,re

#在系统头文件目录下查找系统头文件,可以自行添加头文件路径
def findsysinclude(filename,includepath):
if filename==None:
return None
sysincludepath = ['/usr/include/','/usr/include/c++/4.4/',
'/usr/lib/gcc/i486-linux-gnu/4.4/include/','/usr/include/c++/4.4/i486-linux-gnu/'] #系统头文件目录
includepath += sysincludepath
for onepath in includepath:
if path.isfile(onepath+filename):
return onepath+filename
print 'Not found: '+filename
return None

#读取用户传入的头文件路径参数
args = sys.argv
print args
retest = re.compile(r'\.cpp$|\.c$|\.h$|\.hpp$|\.cc$',re.IGNORECASE)
cppfiles = []
#查找用户项目路径下的所有源文件
for root,dirs,files in os.walk(os.getcwd()):
oldlen = len(cppfiles)
cppfiles += filter(lambda x:retest.search(x)<>None,files) #过滤非C/C++文件
for index in range(oldlen,len(cppfiles)):
cppfiles[index] = root + '/' + cppfiles[index];

oldstdout = sys.stdout
sys.stdout= logfile = open('maketags.log','w')

print 'total cpp files: ' + str(len(cppfiles))
includetest = re.compile(r'\s*#include\s*((<(?P<sysincludefile>.*?)>)|("(?P<userincludefile>.*?)"))') ## *?代表不贪婪匹配

#对每个C++源文件，查找它包含的头文件以及它的头文件所包含的头文件，以次递归直到全部包含
#由于已经遍历过用户目录了，因次只需要再把系统头文件加近来即可
for cppfile in cppfiles:
try:
fp = open(cppfile,'r')
print 'finding in file: '+cppfile
for line in fp:
result = includetest.search(line) #正则匹配头文件
if result <> None:
print 'Matched include line is:'+result.group()
tmp = findsysinclude(result.group('sysincludefile'),args[1:])
tmp2 = findsysinclude(result.group('userincludefile'),args[1:]) #用户头文件也去找系统目录
if tmp<>None and cppfiles.count(tmp)==0:
cppfiles += [tmp]
print 'Added sys files: '+tmp
# tmp2 = path.abspath(path.dirname(cppfile)+'/'+result.group('userincludefile'))
if tmp2<>None and cppfiles.count(tmp2)==0:
cppfiles += [tmp2]
print 'Added user files: '+tmp2
finally:
fp.close()
try:
filelist = open('python_tags_filelist','w')
filelist.writelines('\n'.join(cppfiles))
finally:
filelist.close()

print 'total cpp and include files:'+str(len(cppfiles))
# print 'after delete duplicate files: ' + str(len(set(cppfiles)))
sys.stdout = oldstdout
logfile.close()

os.system('ctags --c++-kinds=+p --fields=+iaS --extra=+q -L python_tags_filelist')

本文链接

Kindle 3 初步体验感受与经验分享

2010-10-02T14:15:00Z

大概一周前让别人从美国带了个kindle3回来，经过几天的体验，得到了第一手的经验，在这里分享一下，给准备买的同学一个参考。

总体感觉，kindle 3 看电子书的感受非常好，由于是背光，不主动发光，眼睛看久了也不会不舒服。虽然和纸制书有差别，但已经很接近了。听歌功能也不错，虽然简单，但是看闲书的时候听听歌还是不错的。然后上网功能就比较弱了，看纯文字的还好，可以看看下面我截的google reader移动版的效果。我认为值得一提的就是全文搜索，随时查阅词典，加备注这三个功能了。这三个功能是纸制书不能比拟的。

缺陷：偶尔会出现卡机甚至死机的情况，这种情况就要强制重启了。

下面放几个截图，kindle自带的截图功能：

kindle store中的书籍介绍

kindle store中的书籍分类列表

阅读扫描版的pdf书籍

全文搜索的结果

看rss订阅生成的mobi格式文章

看优化过的6寸pdf文件

chm格式文件转换成mobi格式后的阅读效果

kindle的home界面，按collection方式显示

最后来一个阅读google reader移动版的截图给大家看看浏览网页的悲剧效果吧：

kindle相关资源：

rss新闻mobi格式在线地址：kindle看新闻 - kindle's rss reader

推荐文件转换工具：mobi creator 和calibre，建议转化成mobi，prc格式，针对kindle3优化过的pdf和txt一般可以不转.

推荐kindle讨论bbs：http://www.hi-pda.com/forum/forumdisplay.php?fid=59 hipda的eink板块

推荐电子书下载的几个：

Index - 亿年书海 - 电子书 wiki 网和hipda，其他的电子书可以下载普通的pdf格式然后转换一下。

ps:在amazon注册你的kindle的时候，记得地址选择美国，这样在kindle store才能看到更多的电子书哦。

ps2：有个多看系统还在测试中，感兴趣的可以刷一下，我目前还没有需要刷机的需求。

希望我的这点东西能帮助你更好的选择，:)

本文链接

COM组件弱引用的简单实现（C++）

2010-08-23T11:31:00Z

COM组件弱引用的简单实现

The simple implementation of the weak reference of the COM object.

说明：我们知道boost用shared_ptr,weak_ptr实现了指针的智能化管理，使用它们可以防止C＋＋常见的内存泄露问题。COM组件的管理和指针类似却又不同，COM组件同样需要在使用的时候调用AddRef和Release来管理组件的引用计数，为了方便管理，ATL库提供了CComPtr等智能组件指针来简化COM组件的使用。可是我的问题是如何去观察一个com组件而不影响它的引用计数，并能在合适的时候将观察对象转换成真实的COM引用。

从COM组件的实现原理，我们可以知道COM组件的弱引用并不好实现。原因在于COM组件的引用计数是包含在COM对象中的，如此，当COM对象被销毁时，也就无法通过获取它的引用计数值来判断该COM对象是否存在了，那么弱引用也就无法判断何时可以将弱引用转换成强引用了。

那么boost的weak_ptr是如何实现的呢？很简单，boost中的shared_ptr,weak_ptr将引用计数和对象本身分离开，这样就算对象本身被销毁了，只要还有弱引用仍在观察该对象，那么弱引用都可以通过判断引用计数中的值来判断对象是否销毁，这样就可以在对象已经销毁后返回失败的强引用即可。

那么COM组件可以借鉴boost的这种实现方式。但是有几个问题：

1.引入额外的引用计数对象后，如何处理内部引用计数和外部引用计数的一致性。

2.由于需要保证内部引用计数和外部引用计数的一致性，线程安全就成了一个问题，因为需要保证对两个计数变量同时增减，单一变量可以用原子增减，多个变量似乎只能用锁来解决了。Linux下面用pthread_mutex_t来实现锁，windows下可以用关键代码段。

我把问题简化了，因此我只是简单实现了类似boost的CComSharedPtr,CComWeakPtr，对于上述两个问题，首先 CcomWeakPtr只能观察由CComSharedPtr封装的COM组件，因此，如果使用了CComPtr来引用一个组件，那么CComWeakPtr是观察不到的，也就是此时即使CComPtr还有效，如果CComSharedPtr管理的组件引用全部失效，那么CComWeakPtr仍然会返回失败。第二，CComSharedPtr中的计数只包含由CComSharedPtr管理的对象个数，而不一定是实际COM组件对象被引用的个数。这样，COM组件对象的引用就包括两个部分：CComSharedPtr管理的和其他指针直接管理的。

因此CComSharedPtr的使用需要注意：若是整个项目的COM对象全部由CComSharedPtr封装管理，那么CComSharedPtr和 CcomWeakPtr会工作的很好。如果项目代码中还有CComPtr等其他指针对COM进行引用的话，那么CComSharedPtr一切正常使用，但是CComWeakPtr在将COM弱引用转换成强引用时，即使失败了，也不代表COM对象被销毁了，只能代表已经没有对应的CComSharedPtr管理的COM引用了。

最后，该实现不是线程安全的，如果需要的话，可以修改代码的增减引用计数部分（具体修改可以参见代码注释的pthread_mutex_t部分，windows下可以用关键代码段）。另外，代码草率完成，定有不适之处，有什么问题可以留言告知。

PS:COM组件的弱引用的需求在实际项目中可能是设计不当的结果，在此实现完全是为了熟悉弱引用的实现原理。

源码：WeakCom

以下是代码实现：

借鉴了boost的大量源码：

1 #include <stdio.h>
2 #include <memory>
3 #include <boost/smart_ptr.hpp>
4 #include <pthread.h>
5 #include <unistd.h>
6 using namespace std;
7 //这个基类就是为了在com组件之外添加额外的引用计数对象，这个是因为当com对象被销毁时无法
8 //访问com内部的引用来探测com对象是否存在，而通过引入额外的引用计数对象，我们可以通过
9 //使用该com对象的弱引用来探测com对象是否存在，直到所有观察该com对象的弱引用全部销毁后，
10 //额外的引用计数对象才会销毁自身。这样就达到了观察com对象却不影响com对象引用计数的目的。
11 //缺点：需要额外维护两个引用计数的一致性，因此无法做到线程安全。而且只能保证维护
12 //CComSharedPtr所管理的com对象，其他如CComPtr不在管理范围内，因此相应的弱引用也只能观察
13 //由CComSharedPtr所管理的com对象，当所有的CComSharedPtr管理的com对象销毁后，弱引用返回
14 class com_counted_base
15 {
16 private:
17
18 com_counted_base( com_counted_base const & );
19 com_counted_base & operator= ( com_counted_base const & );
20
21 long use_count_; // #shared
22 long weak_count_; // #weak + (#shared != 0)
23
24 // pthread_mutex_t refmutex;
25 public:
26
27 com_counted_base(): use_count_( 1 ), weak_count_( 1 )
28 {
29 // pthread_mutex_init(&refmutex,NULL);
30 }
31
32 virtual ~com_counted_base() // nothrow
33 {
34 // pthread_mutex_destroy(&refmutex);
35 }
36
37 // dispose() is called when use_count_ drops to zero, to release
38 // the resources managed by *this.
39
40 virtual void dispose() = 0; // nothrow
41 virtual ULONG com_add_ref() = 0;
42 virtual ULONG com_release() = 0;
43
44 // destroy() is called when weak_count_ drops to zero.
45
46 virtual void destroy() // nothrow
47 {
48 delete this;
49 }
50
51 void add_ref_copy()
52 {
53 // pthread_mutex_lock(&refmutex);
54 ++use_count_;
55 //如果需要测试线程安全，可以在此加入sleep
56 // usleep(1);
57 com_add_ref();
58 // pthread_mutex_unlock(&refmutex);
59 }
60
61 bool add_ref_lock() // true on success
62 {
63
64 if( use_count_ == 0 ) return false;
65 add_ref_copy();
66 return true;
67 }
68
69 void release() // nothrow
70 {
71 // pthread_mutex_lock(&refmutex);
72 com_release();
73 //如果需要测试线程安全，可以在此加入sleep
74 // usleep(1);
75 if( --use_count_ == 0 )
76 {
77 dispose();
78 weak_release();
79 }
80 // pthread_mutex_unlock(&refmutex);
81 }
82 void weak_add_ref() // nothrow
83 {
84 ++weak_count_;
85 }
86
87 void weak_release() // nothrow
88 {
89 if( --weak_count_ == 0 )
90 {
91 destroy();
92 }
93 }
94
95 long use_count() const // nothrow
96 {
97 return static_cast<long const volatile &>( use_count_ );
98 }
99 };
100 template <typename T> class com_counted_impl: public com_counted_base
101 {
102 private:
103 T * px_;
104
105 com_counted_impl( com_counted_impl const & );
106 com_counted_impl & operator= ( com_counted_impl const & );
107
108 typedef com_counted_impl this_type;
109
110 public:
111 explicit com_counted_impl( T * px, bool isaddrefneeded): px_( px )
112 {
113 if(px_!=NULL && isaddrefneeded)
114 com_add_ref();
115 }
116 virtual ULONG com_add_ref()
117 {
118 return px_->AddRef();
119 }
120 virtual ULONG com_release()
121 {
122 return px_->Release();
123 }
124 virtual void dispose() // nothrow
125 {
126 //普通数据指针这里需要delete自己，但是com组件指针不用，因为当com组件引用降为0时会删除自己，和普通数据指针不同
127 }
128 };
129 class com_weak_count;
130
131 class com_shared_count
132 {
133 private:
134
135 com_counted_base* pi_;
136
137 friend class com_weak_count;
138
139 public:
140
141 com_shared_count(): pi_(0) // nothrow
142 {
143 }
144
145 template <typename Y> explicit com_shared_count( Y * p, bool isaddrefneeded = true ): pi_( 0 )
146 {
147 pi_ = new com_counted_impl<Y>( p , isaddrefneeded);
148
149 if( pi_ == 0 )
150 {
151 p->Release();
152 boost::throw_exception( std::bad_alloc() );
153 }
154 }
155
156 ~com_shared_count() // nothrow
157 {
158 if( pi_ != 0 ) pi_->release();
159 }
160
161 com_shared_count(com_shared_count const & r): pi_(r.pi_) // nothrow
162 {
163 if( pi_ != 0 ) pi_->add_ref_copy();
164 }
165
166 explicit com_shared_count(com_weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
167
168 com_shared_count & operator= (com_shared_count const & r) // nothrow
169 {
170 com_counted_base * tmp = r.pi_;
171
172 if( tmp != pi_ )
173 {
174 if( tmp != 0 ) tmp->add_ref_copy();
175 if( pi_ != 0 ) pi_->release();
176 pi_ = tmp;
177 }
178 return *this;
179 }
180 void swap(com_shared_count & r) // nothrow
181 {
182 com_counted_base * tmp = r.pi_;
183 r.pi_ = pi_;
184 pi_ = tmp;
185 }
186
187 long use_count() const // nothrow
188 {
189 return pi_ != 0? pi_->use_count(): 0;
190 }
191
192 bool unique() const // nothrow
193 {
194 return use_count() == 1;
195 }
196
197 friend inline bool operator==(com_shared_count const & a, com_shared_count const & b)
198 {
199 return a.pi_ == b.pi_;
200 }
201
202 };
203
204 class com_weak_count
205 {
206 private:
207
208 com_counted_base * pi_;
209 friend class com_shared_count;
210
211 public:
212
213 com_weak_count(): pi_(0) // nothrow
214 {
215 }
216
217 com_weak_count(com_shared_count const & r): pi_(r.pi_) // nothrow
218 {
219 if(pi_ != 0) pi_->weak_add_ref();
220 }
221
222 com_weak_count(com_weak_count const & r): pi_(r.pi_) // nothrow
223 {
224 if(pi_ != 0) pi_->weak_add_ref();
225 }
226
227 ~com_weak_count() // nothrow
228 {
229 if(pi_ != 0) pi_->weak_release();
230 }
231
232 com_weak_count & operator= (com_shared_count const & r) // nothrow
233 {
234 com_counted_base * tmp = r.pi_;
235 if(tmp != 0) tmp->weak_add_ref();
236 if(pi_ != 0) pi_->weak_release();
237 pi_ = tmp;
238
239 return *this;
240 }
241
242 com_weak_count & operator= (com_weak_count const & r) // nothrow
243 {
244 com_counted_base * tmp = r.pi_;
245 if(tmp != 0) tmp->weak_add_ref();
246 if(pi_ != 0) pi_->weak_release();
247 pi_ = tmp;
248
249 return *this;
250 }
251
252 void swap(com_weak_count & r) // nothrow
253 {
254 com_counted_base * tmp = r.pi_;
255 r.pi_ = pi_;
256 pi_ = tmp;
257 }
258
259 long use_count() const // nothrow
260 {
261 return pi_ != 0? pi_->use_count(): 0;
262 }
263
264 friend inline bool operator==(com_weak_count const & a, com_weak_count const & b)
265 {
266 return a.pi_ == b.pi_;
267 }
268 };
269 inline com_shared_count::com_shared_count( com_weak_count const & r ): pi_( r.pi_ )
270 {
271 if( pi_ == 0 || !pi_->add_ref_lock() )
272 {
273 boost::throw_exception( boost::bad_weak_ptr() );
274 }
275 }
276 template <typename T> class CComWeakPtr;
277 template <typename T> class CComSharedPtr
278 {
279 private:
280 T* px;
281 com_shared_count pn;
282 typedef CComSharedPtr<T> this_type;
283 public:
284
285 CComSharedPtr(): px(0), pn() // never throws in 1.30+
286 {
287 }
288 ~CComSharedPtr()
289 {
290
291 }
292 explicit CComSharedPtr( T* p ): px( p ), pn( p )
293 {
294 }
295 // generated copy constructor, assignment, destructor are fine...
296
297 template <typename Y> CComSharedPtr & operator=(CComSharedPtr<Y> const & r) // never throws
298 {
299 px = r.px;
300 pn = r.pn; // shared_count::op= doesn't throw
301 return *this;
302 }
303 template <typename Y> explicit CComSharedPtr(CComWeakPtr<Y> const & r): pn(r.pn) // may throw
304 {
305 // it is now safe to copy r.px, as pn(r.pn) did not throw
306 px = r.px;
307 }
308
309 template<typename Y> CComSharedPtr(CComSharedPtr<Y> const & r): px(r.px), pn(r.pn)
310 {
311
312 }
313 template<class Y>
314 CComSharedPtr(CComSharedPtr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<T *>(r.px)), pn(r.pn)
315 {
316 if(px == 0) // need to allocate new counter -- the cast failed
317 {
318 pn = com_shared_count();
319 }
320 }
321
322 operator T*() const
323 {
324 return px;
325 }
326
327 //使用该操作符返回的指针被修改指向新的com组件后，必须调用init_count函数进行计数初始化
328 T** operator&() throw()
329 {
330 // BOOST_ASSERT(px==NULL);
331 return &px;
332 }
333
334 void init_com_count()
335 {
336 //初始化通过获取原始数据指针直接修改的com引用，由于直接修改原始com引用，跳过了
337 //额外引用计数的初始化，因此需要调用该函数进行额外计数初始化。
338 //由于直接修改的com引用必然是已经调用过AddRef的，因此传递false以表示不再需要AddRef了。
339 com_shared_count temp(px,false);
340 pn = temp;
341 }
342
343 void reset() // never throws in 1.30+
344 {
345 this_type().swap(*this);
346 }
347
348 void reset(T * p) // Y must be complete
349 {
350 BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
351 this_type(p).swap(*this);
352 }
353 T& operator* () const // never throws
354 {
355 BOOST_ASSERT(px != 0);
356 return *px;
357 }
358
359 T * operator-> () const // never throws
360 {
361 BOOST_ASSERT(px != 0);
362 return px;
363 }
364
365 T * get() const // never throws
366 {
367 return px;
368 }
369 // implicit conversion to "bool"
370 operator bool () const
371 {
372 return px != 0;
373 }
374 // operator! is redundant, but some compilers need it
375 bool operator! () const // never throws
376 {
377 return px == 0;
378 }
379
380 bool unique() const // never throws
381 {
382 return pn.unique();
383 }
384
385 long use_count() const // never throws
386 {
387 return pn.use_count();
388 }
389 void swap(CComSharedPtr<T>& other)
390 {
391 std::swap(px, other.px);
392 pn.swap(other.pn);
393 }
394 private:
395 template<class Y> friend class CComSharedPtr;
396 template<class Y> friend class CComWeakPtr;
397 };
398 template<class T, class U> CComSharedPtr<T> dynamic_pointer_cast(CComSharedPtr<U> const & r)
399 {
400 return CComSharedPtr<T>(r, boost::detail::dynamic_cast_tag());
401 }
402 template <typename T> class CComWeakPtr
403 {
404 private:
405
406 typedef CComWeakPtr<T> this_type;
407
408 public:
409
410 CComWeakPtr(): px(0), pn() // never throws in 1.30+
411 {
412 }
413
414 // generated copy constructor, assignment, destructor are fine
415
416
417 //
418 // The "obvious" converting constructor implementation:
419 //
420 // template<class Y>
421 // weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
422 // {
423 // }
424 //
425 // has a serious problem.
426 //
427 // r.px may already have been invalidated. The px(r.px)
428 // conversion may require access to *r.px (virtual inheritance).
429 //
430 // It is not possible to avoid spurious access violations since
431 // in multithreaded programs r.px may be invalidated at any point.
432 //
433
434 template <typename Y> CComWeakPtr(CComWeakPtr<Y> const & r): pn(r.pn) // never throws
435 {
436 px = r.lock().get();
437 }
438
439 template <typename Y> CComWeakPtr(CComSharedPtr<Y> const & r): px(r.px), pn(r.pn) // never throws
440 {
441 }
442
443 template <typename Y> CComWeakPtr & operator=(CComWeakPtr<Y> const & r) // never throws
444 {
445 px = r.lock().get();
446 pn = r.pn;
447 return *this;
448 }
449 template <typename Y> CComWeakPtr & operator=(CComSharedPtr<Y> const & r) // never throws
450 {
451 px = r.px;
452 pn = r.pn;
453 return *this;
454 }
455
456 CComSharedPtr<T> lock() const // never throws
457 {
458 #if defined(BOOST_HAS_THREADS)
459
460 // optimization: avoid throw overhead
461 if(expired())
462 {
463 return CComSharedPtr<T>();
464 }
465
466 try
467 {
468 return CComSharedPtr<T>(*this);
469 }
470 catch(boost::bad_weak_ptr const &)
471 {
472 // Q: how can we get here?
473 // A: another thread may have invalidated r after the use_count test above.
474 return CComSharedPtr<T>();
475 }
476
477 #else
478
479 // optimization: avoid try/catch overhead when single threaded
480 return expired()? CComSharedPtr<T>(): CComSharedPtr<T>(*this);
481
482 #endif
483 }
484
485 long use_count() const // never throws
486 {
487 return pn.use_count();
488 }
489
490 bool expired() const // never throws
491 {
492 return pn.use_count() == 0;
493 }
494
495 void reset() // never throws in 1.30+
496 {
497 this_type().swap(*this);
498 }
499
500 void swap(this_type & other) // never throws
501 {
502 std::swap(px, other.px);
503 pn.swap(other.pn);
504 }
505
506 // Tasteless as this may seem, making all members public allows member templates
507 // to work in the absence of member template friends. (Matthew Langston)
508
509 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
510
511 private:
512
513 template<class Y> friend class CComWeakPtr;
514 template<class Y> friend class CComSharedPtr;
515
516 #endif
517
518 T * px; // contained pointer
519 com_weak_count pn; // reference counter
520
521 };
522 HRESULT CreateComTestInstance(const IID& iid,void** ppv)
523 {
524 ComTest *t = new ComTest;
525 HRESULT hr = t->QueryInterface(iid,ppv);
526
527 t->Release();
528 return hr;
529 }
530 class SharedTest
531 {
532
533 public:
534 CComSharedPtr<IPrintTest> spCom;
535 CComWeakPtr<IUnknown> wkcom;
536 };
537 /*
538 *测试多线程的方法，线程安全测试用
539 * void* testpthread(void* voidCom)
540 {
541 CComSharedPtr<IPrintTest> spCom = *((CComSharedPtr<IPrintTest>*)voidCom);
542 int i;
543
544 usleep(1);
545 for(i=0;i<5;i++)
546 {
547 CComSharedPtr<IPrintTest> spComtest;
548 spComtest = spCom;
549 spComtest->printref();
550 }
551
552 CComSharedPtr<IPrintTest> spComtest2[5];
553 for(i=0;i<5;i++)
554 {
555 spComtest2[i] = spCom;
556 spComtest2[i]->printref();
557 }
558 return 0;
559 }
560 */
561 int main()
562 {
563 SharedTest mysharedtest;
564 {
565
566 CComSharedPtr<IPrintTest> spIPT;
567 HRESULT hr = CreateComTestInstance(IID_IPrintTest,(void**)&spIPT);
568 spIPT.init_com_count();
569 if (SUCCEEDED(hr))
570 {
571 }
572 mysharedtest.spCom = spIPT;
573 mysharedtest.wkcom = spIPT;
574 {
575 CComSharedPtr<IPrintTest> spIPTfrom_wk(mysharedtest.wkcom.lock(),boost::detail::dynamic_cast_tag());
576 }
577 }
578 /* 测试多线程的线程安全
579 * pthread_t pid[10];
580
581 for(int i=0;i<10;i++)
582 {
583 pthread_create(&pid[i],NULL,testpthread,(void*)&mysharedtest.spCom);
584 }
585 usleep(1000);
586 for(int i=0;i<10;i++)
587 {
588 pthread_join(pid[i],NULL);
589 }
590 */
591 mysharedtest.spCom.reset();
592 CComSharedPtr<IPrintTest> spIPTfrom_wk2(mysharedtest.wkcom.lock(),boost::detail::dynamic_cast_tag());
593 if (spIPTfrom_wk2)
594 {
595 }
596 else
597 {
598
599 printf("get strong ref failed. The ref has been deleted.\n");
600 mysharedtest.wkcom.reset();
601 }
602 return 0;
603 }
604

本文链接

Milestone手机出现SD卡受损提示的解决方法

2010-08-08T07:18:00Z

今天ms开机出现SD卡受损的提示，说是sd卡已损坏，需要格式化，网上查了一下好多android的手机很多会出现这个情况。于是我拷贝sd卡上的所有文件备份一下，拷贝的过程中发现有1个文件拷贝失败，说是不存在该文件，我猜可能sd卡的目录结构有问题，于是用win自带的chkdsk命令检测一下，果然发现有错误，于是修复一下，重启手机，sd卡正常了。

终于不用格式化SD卡了。出现同样问题的可以参考一下。不成功的话，可能就是还有其他原因了。

本文链接

[总结]最原始的COM组件调用过程(不使用注册表信息)

2010-07-28T03:40:00Z

最近因为项目的关系开始研究COM组件了,以前都认为COM过时了,所以也没怎么接触. 现在好好补补课了.

一般调用COM都是通过注册表找到它的位置, 然后调用COM库的标准函数. 这些封装无疑使得我这个初学者无法了解里面到底做了什么, 而且注册表和COM库标准函数都是windows提供的, 但是COM这个思想是可以在Linux下实现的. 只要知道它的实现原理就行了. 因此我就试着用最基本的调用方法来使用COM组件, 以了解其调用过程和原理.

首先,我用vs的ATL创建了一个简单的ATL项目test, 然后添加了一个简单对象Mytest, 该对象实现了一个IMytest接口,该接口有一个testfunc函数. 编译生成了一堆自动产生的文件, 我们只需要最后的test.dll文件和test.h文件. 有了这两个文件,我们就可以使用该组件中实现的接口了.

然后,我创建了一个win32控制台项目来测试一下如何不使用注册表来调用COM组件中的接口方法. 不使用注册表,那么该test.DLL文件也就不需要使用regsvr32.exe来注册组件了,我们使用手动加载的方式来使用COM组件. (将test.dll放在win32程序运行目录下,将test.H文件放在win32工程目录下)

过程如下:

// usetest.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "test.h"
//#import "test.dll"
#include <iostream>
using namespace std;
typedef HRESULT ( __stdcall *CREATEFUNC)(REFCLSID clsid,REFIID iid,void** ppobj);
int _tmain(int argc, _TCHAR* argv[])
{
HINSTANCE hi= ::LoadLibrary(L"test.dll");
if(hi!=NULL)
{
cout<<"dll loaded."<<endl;
CREATEFUNC CreateInstance = (CREATEFUNC)::GetProcAddress(hi,"DllGetClassObject");
if(CreateInstance!=NULL)
{
cout<<"get DllGetClassObject method - Success."<<endl;
IClassFactory* pICF = NULL;
HRESULT hr = CreateInstance(__uuidof(Mytest),IID_IClassFactory,(void**)&pICF);
if(SUCCEEDED(hr))
{
cout<<"create IClassFactory - Success."<<endl;
IMytest* pIMytest=NULL;
HRESULT hr2 = pICF->CreateInstance(NULL,__uuidof(IMytest),(void**)&pIMytest);
if (SUCCEEDED(hr2))
{
cout<<"get interface - Success."<<endl;
HRESULT hr3=pIMytest->testfunc(1);
if (SUCCEEDED(hr3))
{
cout<<"Invoke interface method OK."<<endl;
}
pIMytest->Release();
}
pICF->Release();
}
}
FreeLibrary(hi);
}
return 0;
}

和windows相关的只用到了dll加载相关的API,而这些在其他系统下都有对应的api. 所以如果想在其他系统下实现以下COM的调用, 还是可以的.

更进一步,可以使用xml文件来维护com组件的位置信息, 然后写一套与系统无关的通过xml文件查找com组件的库,这样就可以实现com组件的跨平台了.

哈哈,想法不错,实现起来还是有难度的.

本文链接

【总结】修复Ubuntu和Win7双系统菜单Grub2

2010-07-05T07:09:00Z

win7软解的原因，不能将grub2装在MBR上。因此我将grub2装在我的ubuntu分区上了。 ubuntu是装在逻辑分区里面的，刚开始grub2并不能引导我的ubuntu，

一开机就出现win7的启动选择界面。只能手动进入grub4dos来启动ubuntu。在网上找了easybcd添加了linux的启动菜单，但是不管用，可能是easybcd对grub2支持不好吧，easybcd1.7最后更新时间是2008年，很久没有改进了。

绝望之中，我找到了下面这个文章

http://linux.ctocio.com.cn/257/9486757.shtml

教你修复grub2到指定的分区的。

我按照提示将grub2修复到/DEV/SDA5分区上（我的ubuntu是在逻辑分区的第一个），终于开机就能看到grub2的菜单选择界面了。

grub-probe -t device /boot/grub 查看grub2的安装位置，显示 /dev/sda5。正和我意。可以不用破坏win7的软解了。

里面英文的步骤很详细，我简化如下：

用光盘livecd启动，加载ubuntu所在的分区sudo mount /dev/sda5 /mnt ，如果有单独的boot分区，则加载boot分区sudo mount /dev/sdYY /mnt/boot，sdYY为boot所在的独立分区，依次执行如下内容：

sudo mount --bind /dev/ /mnt/dev
sudo mount --bind /usr/ /mnt/usr
sudo mount --bind /proc/ /mnt/proc
sudo chroot /mnt
update-grub
grub-install /dev/sda

这样就修复好了。然后 CTRL-D退出chroot，sudo umount /mnt/dev，umount /mnt ，然后重启，退出livecd光盘。这样就可以正常进入ubuntu了。

不过现在多重菜单还不完整，进入ubuntu后，再次执行sudo update-grub更新当前安装的系统。然后重启，就可以看到所有安装好的系统了。

终于搞定 ubuntu和win7双系统的问题了，要兼顾MBR还是有点麻烦。

本文链接

使用C#批量转换文本文件编码为UTF8

2010-07-04T01:28:00Z

现在很多地方都要求程序源码用UTF8格式，因此需要将原来的源码转换一下，手动转显然太累了。

发现c#还真是简单啊，几行代码就搞定了。试了一下GBK转换成UTF8编码格式，没什么问题了。

static void Main(string[] args)
{
string dir, filters;
Console.WriteLine("Please input the directory:");
dir = Console.ReadLine();
Console.WriteLine("Please input the filter(such as *.c,*.cpp):");
filters = Console.ReadLine();
Console.WriteLine("The following files will be converted:");
List<string> destfiles = new List<string>();
foreach (string filter in filters.Split(','))
{
foreach (var eachfileinfo in new DirectoryInfo(dir).GetFiles(filter, SearchOption.AllDirectories))
{
destfiles.Add(eachfileinfo.FullName);
Console.WriteLine(eachfileinfo.FullName);
}
}
Console.WriteLine("You Sure? (y or n)");
string ans = Console.ReadLine();
if (ans.Equals("y", StringComparison.OrdinalIgnoreCase))
{
foreach (string destfile in destfiles)
{
File.WriteAllText(destfile, File.ReadAllText(destfile,Encoding.Default), Encoding.UTF8);
}
Console.WriteLine("finished.");
}
else
{
Console.WriteLine("Nothing changed.");
}
Console.WriteLine("Press any key to exit.");
Console.ReadLine();
}

本文链接