|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
16 楼』:
Python
编辑词条
Python（KK 英语发音：/ˈpaɪθən/）是一种面向对象、直译式计算机程序设计语言。也是一种功能强大而完善的通用型语言，已经具有十多年的发展历史，成熟且稳定。Python 具有脚本语言中最丰富和强大的类库，足以支持绝大多数日常应用。 Python语法简捷而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，它能够很轻松的把用其他语言制作的各种模块（尤其是C/C++）轻松地联结在一起。Python的名字来源于一个喜剧。也许最初设计Python这种语言的人并没有想到Python会在工业和科研上获得如此广泛的使用。[1]
快速导航
知乎精选
中文名 蟒蛇
别名 蟒蛇语言
设计者 Guido van Rossum
荣誉 2010年度编程语言
外文名 python
发行时间 1991年
最新版本 3.4.0，2.7.8
概况
知乎精选最新
目
录
1概要介绍
2产生起源
3风格介绍
4特色缺点
5功能介绍
6设计定位
7CGI介绍
服务器
程序
环境变量
8执行情况
9基本语法
10应用介绍
11工具功能
12版本介绍
13开发环境
14其他相关
1 概要介绍 编辑
Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。自从20世纪90年代初Python语言诞生至今，它逐渐被广泛应用于处理系统管理任务和Web编程。Python已经成为最受欢迎的程序设计语言之一。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。自从2004年以后，python的使用率是呈线性增长。[2]
由于Python语言的简洁、易读以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python教授程序设计课程。例如麻省理工学院的计算机科学及编程导论课程就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。
说起科学计算，首先会被提到的可能是MATLAB。然而除了MATLAB的一些专业性很强的工具箱还无法替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相应的扩展库。和MATLAB相比，用Python做科学计算有如下优点：
● 首先，MATLAB是一款商用软件，并且价格不菲。而Python完全免费，众多开源的科学计算库都提供了Python的调用接口。用户可以在任何计算机上免费安装Python及其绝大多数扩展库。
Python LOGO
● 其次，与MATLAB相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。
● 最后，MATLAB主要专注于工程和科学计算。然而即使在计算领域，也经常会遇到文件管理、界面设计、网络通信等各种需求。而Python有着丰富的扩展库，可以轻易完成各种高级任务，开发者可以用Python实现完整应用程序所需的各种功能。
英文简介
Python is an object-oriented explanation of computer programming languages, is a powerful and well-size-fits-all language, has been more than a decade of development, maturity and stability. Python scripting language with the most rich and powerful class library, enough to support the vast majority of day-to-day applications.
This language has a very simple and clear characteristics of grammar, for a variety of high-level mission to complete, almost all of the operating system to run.
At present, this language is related to the rapid technological development, the rapid expansion of the number of users, and related resources.
这种语言具有非常简捷而清晰的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中运行。
目前，基于这种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
2 产生起源 编辑
Python的创始人为Guido van Rossum。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，做为ABC 语言的一种继承。之所以选中Python（大蟒蛇的意思）作为程序的名字，是因为他是一个叫Monty Python的喜剧团体的爱好者。
ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是非开放造成的。Guido 决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。
就这样，Python在Guido手中诞生了。实际上，第一个实现是在Mac机上。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。
3 风格介绍 编辑
风格
Python在设计上坚持了清晰划一的风格，这使得Python成为一门易读、易维护，并且被大量用户所欢迎的、用途广泛的语言。
设计者开发时总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。这在由Tim Peters写的python格言（称为The Zen of Python）里面表述为：There should be one-- and preferably only one --obvious way to do it. 这正好和Perl语言（另一种功能类似的高级动态语言）的中心思想TMTOWTDI（There's More Than One Way To Do It）完全相反。
Python的作者有意的设计限制性很强的语法，使得不好的编程习惯（例如if语句的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的缩进规则。
一个和其他大多数语言（如C）的区别就是，一个模块的界限，完全是由每行的首字符在这一行的位置来决定的（而C语言是用一对花括号{}来明确的定出模块的边界的，与字符的位置毫无关系）。这一点曾经引起过争议。因为自从C这类的语言诞生后，语言的语法含义与字符的排列方式分离开来，曾经被认为是一种程序语言的进步。不过不可否认的是，通过强制程序员们缩进（包括if，for和函数定义等所有需要使用模块的地方），Python确实使得程序更加清晰和美观。
4 特色缺点 编辑
特色：
简单————Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。
易学————就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法。
速度快：Python 的底层是用 C 语言写的，很多标准库和第三方库也都是用 C 写的，运行速度非常快。
免费、开源————Python是FLOSS（自由/开放源码软件）之一。简单地说，你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。这是为什么Python如此优秀的原因之一——它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。
高层语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。
可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就可以在下述任何平台上面运行。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、
Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE甚至还有PocketPC和Symbian！
解释性————这一点需要一些解释。一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码 运行 程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。
面向对象————Python即支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。
可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。
丰富的库————Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
规范的代码：Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。
概括————Python确实是一种十分精彩又强大的语言。它合理地结合了高性能与使得编写程序简单有趣的特色。
缺点：
单行语句和命令行输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。
独特的语法
这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。最常见的情况是tab和空格的混用会导致错误，而这是用肉眼无法分别的。
无类型
作为一种动态语言，随时随地创建和使用变量是Python给我们带来的巨大的便利。但是它也会使得程序不严谨，某些错误只有在运行中才可能出现。所以，使用Python编程的时候，要对类型做到心里有数。这也使得Python的IDE工具无法提供便利的自动完成等功能。
关于“无类型”的说法，是完全错误的。一看就是不了解python的人写的。python是一种“强类型”“动态绑定”。
运行速度慢：这里是指与C和c++相比。
5 功能介绍 编辑
Python拥有一个强大的标准库。Python语言的核心只包含数字、字符串、列表、字典、文件等常见类型和函数，而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能。Python标准库命名接口清晰、文档良好，很容易学习和使用。
Python社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能无所不包，覆盖科学计算、Web开发、数据库接口、图形系统多个领域，并且大多成熟而稳定。第三方模块可以使用Python或者C语言编写。SWIG,SIP常用于将C语言编写的程序库转化为Python模块。Boost C++ Libraries包含了一组库，Boost.Python，使得以 Python 或 C++ 编写的程序能互相调用。借助于拥有基于标准库的大量工具、能够使用低级语言如C和可以作为其他库接口的C++，Python已成为一种强大的应用于其他语言与工具之间的胶水语言。
Python标准库的主要功能有：
文本处理，包含文本格式化、正则表达式匹配、文本差异计算与合并、Unicode支持，二进制数据处理等功能
文件处理，包含文件操作、创建临时文件、文件压缩与归档、操作配置文件等功能
操作系统功能，包含线程与进程支持、IO复用、日期与时间处理、调用系统函数、写日记(logging)等功能
网络通信，包含网络套接字，SSL加密通信、异步网络通信等功能
网络协议，支持HTTP，FTP，SMTP，POP，IMAP，NNTP，XMLRPC等多种网络协议，并提供了编写网络服务器的框架
W3C格式支持，包含HTML，SGML，XML的处理。
其它功能，包括国际化支持、数学 运 算、HASH、Tkinter等
6 设计定位 编辑
Python的设计哲学是“优雅”、“明确”、“简单”。因此，Perl语言中“总是有多种方法来做同一件事”的理念在Python开发者中通常是难以忍受的。Python开发者的哲学是“用一种方法，最好是只有一种方法来做一件事”。在设计Python语言时，如果面临多种选择，Python开发者一般会拒绝花俏的语法，而选择明确的没有或者很少有歧义的语法。由于这种设计观念的差异，Python源代码通常被认为比Perl具备更好的可读性，并且能够支撑大规模的软件开发。这些准则被称为Python格言。在Python解释器内运行import this可以获得完整的列表。
Python开发人员尽量避开不成熟或者不重要的优化。一些针对非重要部位的加快运行速度的补丁通常不会被合并到Python内。所以很多人认为Python很慢。不过，根据二八定律，大多数程序对速度要求不高。在某些对运行速度要求很高的情况，Python设计师倾向于使用JIT技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是PyPy。
Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。
虽然Python可能被粗略地分类为“脚本语言”（script language），但实际上一些大规模软件开发计划例如Zope、Mnet及BitTorrent，Google也广泛地使用它。Python的支持者较喜欢称它为一种高级动态编程语言，原因是“脚本语言”泛指仅作简单程序设计任务的语言，如shell script、VBScript等只能处理简单任务的编程语言，并不能与Python相提并论。
Python本身被设计为可扩充的。并非所有的特性和功能都集成到语言核心。Python提供了丰富的API和工具，以便程序员能够轻松地使用C语言、C++、Cython来编写扩充模块。Python编译器本身也可以被集成到其它需要脚本语言的程序内。因此，很多人还把Python作为一种“胶水语言”（glue language）使用。使用Python将其他语言编写的程序进行集成和封装。在Google内部的很多项目，例如Google Engine使用C++编写性能要求极高的部分，然后用Python或Java/Go调用相应的模块。《Python技术手册》的作者马特利（Alex Martelli）说：“这很难讲，不过，2004 年，Python 已在 Google 内部使用，Google 召募许多 Python 高手，但在这之前就已决定使用Python，他们的目的是 Python where we can, C++ where we must，在操控硬件的场合使用 C++，在快速开发时候使用 Python。”
7 CGI介绍 编辑
CGI 目前由NCSA维护，
CGI(Common Gateway Interface)，通用网关接口，它是一段程序，运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。
CGI程序可以是Python脚本、Perl脚本、Shell脚本、C或者C++程序等。
服务器
在你进行CGI编程前，确保您的Web服务器支持CGI及已经配置了CGI的处理程序。
所有的HTTP服务器执行CGI程序都保存在一个预先配置的目录。这个目录被称为CGI目录，并按照惯例，它被命名为/var/www/cgi-bin目录。
CGI文件的扩展名为.cgi，python也可以使用.py扩展名。
默认情况下，Linux服务器配置运行的cgi-bin目录中为/var/www。
如果你想指定的其他运行CGI脚本的目录，可以修改httpd.conf配置文件，
1
2
3
4
5
6
7
8
9
<Directory"/var/www/cgi-bin">
AllowOverrideNone
OptionsExecCGI
Orderallow,deny
Allowfromall
</Directory>
<Directory"/var/www/cgi-bin">
OptionsAll
</Directory>
程序
使用Python创建第一个CGI程序，文件名为hello.py，文件位于/var/www/cgi-bin目录中，内容如下，
1
2
3
4
5
6
7
8
9
10
#!/usr/bin/envpython
print("Content-type:text/html\r\n\r\n")
print("<html>")
print("<head>")
print("")
print("</head>")
print("<body>")
print("<h2>HelloWord!ThisismyfirstCGIprogram")
print("</body>")
print("</html>")
以上程序在浏览器访问显示结果如下：
1
HelloWord!ThisismyfirstCGIprogram
这个的hello.py脚本是一个简单的Python脚本，脚本第一的输出内容"Content-type:text/html\r\n\r\n"发送到浏览器并告知浏览器显示的内容类型为"text/html"。
环境变量
所有的CGI程序都接收以下的环境变量，
变量名
描述
CONTENT_TYPE
这个环境变量的值指示所传递来的信息的MIME类型。目前，环境变量CONTENT_TYPE一般都是：application/x-www-form-urlencoded,他表示数据来自于HTML表单。
CONTENT_LENGTH
如果服务器与CGI程序信息的传递方式是POST，这个环境变量即使从标准输入STDIN中可以读到的有效数据的字节数。这个环境变量在读取所输入的数据时必须使用。
HTTP_COOKIE 客户机,内的,COOKIE,内容
HTTP_USER_AGENT 提供包含了版本数或其他专有数据的客户浏览器信息
PATH_INFO
这个环境变量的值表示紧接在CGI程序名之后的其他路径信息。它常常作为CGI程序的参数出现。
QUERY_STRING
如果服务器与CGI程序信息的传递方式是GET，这个环境变量的值即使所传递的信息。这个信息经跟在CGI程序名的后面，两者中间用一个问号'?'分隔。
REMOTE_ADDR
这个环境变量的值是发送请求的客户机的IP地址，例如上面的192.168.1.67。这个值总是存在的。而且它是Web客户机需要提供给Web服务器的唯一标识，可以在CGI程序中用它来区分不同的Web客户机。
REMOTE_HOST
这个环境变量的值包含发送CGI请求的客户机的主机名。如果不支持你想查询，则无需定义此环境变量。
REQUEST_METHOD
提供脚本被调用的方法。对于使用 HTTP/1.0 协议的脚本，仅 GET 和 POST 有意义。
SCRIPT_FILENAME CGI脚本的完整路径
SCRIPT_NAME CGI脚本的的名称
SERVER_NAME 这是你的,WEB,服务器的主机名,别名或IP地址
SERVER_SOFTWARE 这个环境变量的值包含了调用CGI程序的HTTP服务器的名称和版本号,例如
以下是一个简单的CGI脚本输出CGI的环境变量：
1
2
3
4
5
#!/usr/bin/pythonimportosprint"Content-type:text/html\r\n\r\n";
print"<fontsize=+1>Environment</font><\br>";
forparaminos.environ.keys():
print"<b>%20s</b>:%s<\br>"
%(param,os.environ[param])
8 执行情况 编辑
Python在执行时，首先会将.py文件中的源代码编译成Python的byte code（字节码），然后再由Python Virtual Machine（Python虚拟机）来执行这些编译好的byte code。这种机制的基本思想跟Java，.NET是一致的。然而，Python Virtual Machine与Java或.NET的Virtual Machine不同的是，Python的Virtual Machine是一种更高级的Virtual Machine。这里的高级并不是通常意义上的高级，不是说Python的Virtual Machine比Java或.NET的功能更强大，而是说和Java 或.NET相比，Python的Virtual Machine距离真实机器的距离更远。或者可以这么说，Python的Virtual Machine是一种抽象层次更高的Virtual Machine。
基于C的Python编译出的字节码文件，通常是.pyc格式。
除此之外，Python还可以以交互模式运行，比如主流操作系统Unix/Linux、Mac、window都可以直接在命令模式下直接运行Python交互环境。直接下达操作指令即可实现交互操作。
9 基本语法 编辑
Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和惊喜。
缩进
Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出（Off-side规则），而非使用花括号或者某种关键字。增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。缩进成为了语法的一部分。例如if语句：
注:上述例子为python 3.0版本的代码,@代表一个空格
根据PEP的规定，必须使用4个空格来表示每级缩进（不清楚4个空格的规定如何，在实际编写中可以自定义空格数，但是要满足每级缩进间空格数相等）。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为兼容很旧的的Python程序和某些有问题的编辑程序。
流程控制语句
if语句，当条件成立时运行语句块。经常与else, elif(相当于else if) 配合使用。
for语句，遍列列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
while语句，当条件为真时，循环运行语句块。
try语句。与except,finally配合使用处理在程序运行中出现的异常情况。
class语句。用于定义类型。
def语句。用于定义函数和类型的方法。
pass语句。表示此行为空，不运行任何操作。
assert语句。用于程序调适阶段时测试运行条件是否满足。
with语句。Python2.6以后定义的语法，在一个场景中运行语句块。比如，运行语句块前加密，然后在语句块运行退出后解密。
yield语句。在迭代器函数内使用，用于返回一个元素。自从Python 2.5版本以后。这个语句变成一个运算符。
raise语句。制造一个错误。
import语句。导入一个模块或包。
from import语句。从包导入模块或从模块导入某个对象。
import as语句。将导入的对象赋值给一个变量。
in语句。判断一个对象是否在一个字符串/列表/元组里。
表达式
Python的表达式写法与C/C++类似。只是在某些写法有所差别。
主要的算术运算符与C/C++类似。+, -, *, /, //, **, ~, %分别表示加法或者取正、减法或者取负、乘法、除法、整除、乘方、取补、取模。>>, <<表示右移和左移。&, |, ^表示二进制的AND, OR, XOR运算。>, <, ==, !=, <=, >=用于比较两个表达式的值，分别表示大于、小于、等于、不等于、小于等于、大于等于。在这些运算符里面，~, |, ^, &, <<, >>必须应用于整数。
Python使用and, or, not表示逻辑运算。
is, is not用于比较两个变量是否是同一个对象。in, not in用于判断一个对象是否属于另外一个对象。
Python支持“列表推导式”（list comprehension），比如计算0-9的平方和:
>>> sum(x * x for x in range(10))
285
Python使用lambda表示匿名函数。匿名函数体只能是表达式。比如：
>>> add=lambda x, y : x + y
>>> add(3,2)
5
Python使用y if cond else x表示条件表达式。意思是当cond为真时，表达式的值为y，否则表达式的值为x。相当于C++和Java里的cond?y:x。
Python区分列表(list)和元组(tuple)两种类型。list的写法是[1,2,3]，而tuple的写法是(1,2,3)。可以改变list中的元素，而不能改变tuple。在某些情况下，tuple的括号可以省略。tuple对于赋值语句有特殊的处理。因此，可以同时赋值给多个变量，比如：
>>> x, y=1,2#同时给x,y赋值，最终结果：x=1, y=2
特别地，可以使用以下这种形式来交换两个变量的值：
>>> x, y=y, x #最终结果：y=1, x=2
Python使用'(单引号)和"(双引号)来表示字符串。与Perl、Unix Shell语言或者Ruby、Groovy等语言不一样，两种符号作用相同。一般地，如果字符串中出现了双引号，就使用单引号来表示字符串;反之则使用双引号。如果都没有出现，就依个人喜好选择。出现在字符串中的\(反斜杠)被解释为特殊字符，比如\n表示换行符。表达式前加r指示Python不解释字符串中出现的\。这种写法通常用于编写正则表达式或者Windows文件路径。
Python支持列表切割(list slices)，可以取得完整列表的一部分。支持切割操作的类型有str, bytes, list, tuple等。它的语法是...[left:right]或者...[left:right:stride]。假定nums变量的值是[1, 3, 5, 7, 8, 13, 20]，那么下面几个语句为真：
nums[2:5] == [5, 7, 8] 从下标为2的元素切割到下标为5的元素，但不包含下标为5的元素。
nums[1:] == [3, 5, 7, 8, 13, 20] 切割到最后一个元素。
nums[:-3] == [1, 3, 5, 7] 从最开始的元素一直切割到倒数第3个元素。
nums[:] == [1, 3, 5, 7, 8, 13, 20] 返回所有元素。改变新的列表不会影响到nums。
nums[1:5:2] == [3, 7] 从下标为1的元素切割到下标为5的元素但不包含下标为5的元素，且步长为2
函数
Python的函数支持递归、默认参数值、可变参数，但不支持函数重载。为了增强代码的可读性，可以在函数后书写“文档字符串”(Documentation Strings，或者简称docstrings)，用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。比如：
>>>def randint(a, b):... "Return random integer in range [a, b], including both end points."...>>>help(randint)Help on function randint in module __main__: randint(a, b) Return random integer inrange[a, b], including both end points.
对象的方法
对象的方法是指绑定到对象的函数。调用对象方法的语法是instance.method(arguments)。它等价于调用Class.method(instance, arguments)。当定义对象方法时，必须显式地定义第一个参数，一般该参数名都使用self，用于访问对象的内部数据。这里的self相当于C++, Java里面的this变量，但是我们还可以使用任何其它合法的参数名，比如this 和 mine 等，self与C++,Java里面的this不完全一样，它可以被看作是一个习惯性的用法，我们传入任何其它的合法名称都行，比如：
Python认识一些以“__”开始并以“__”结束的特殊方法名，它们用于实现运算符重载和实现多种特殊功能。
类型
Python采用动态类型系统。在编译的时候，Python不会检查对象是否拥有被调用的方法或者属性，而是直至运行时，才做出检查。所以操作对象时可能会抛出异常。不过，虽然Python采用动态类型系统，它同时也是强类型的。Python禁止没有明确定义的操作，比如数字加字符串。
与其它面向对象语言一样，Python允许程序员定义类型。构造一个对象只需要像函数一样调用类型即可，比如，对于前面定义的Fish类型，使用Fish()。类型本身也是特殊类型type的对象(type类型本身也是type对象)，这种特殊的设计允许对类型进行反射编程。
Python内置丰富的数据类型。与Java、C++相比，这些数据类型有效地减少代码的长度。下面这个列表简要地描述了Python内置数据类型(适用于Python 3.x)：
类型
描述
例子
备注
str 一个由字符组成的不可更改的有串行
'Wikipedia'
"Wikipedia"
"""Spanning
multiple
lines"""
在Python,3,x里,字符串由Unicode字符组成
bytes 一个由字节组成的不可更改的有串行 b'Some,ASCII'b",Some,ASCII"
list 可以包含多种类型的可改变的有串行 [4,0,'string',True]
tuple 可以包含多种类型的不可改变的有串行 (4,0,'string',True)
set,frozenset 与数学中集合的概念类似,无序的,每个元素唯一
{4.0, 'string', True}
frozenset([4.0, 'string', True])
dict 一个可改变的由键值对组成的无串行 {'key1':,1,0,3:,False}
int 精度不限的整数 42
float 浮点数,精度与系统相关 3.1415927
complex 复数 3+2,7j
bool 逻辑值,只有两个值：真,假 TrueFalse
除了各种数据类型，Python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后的Python代码、运行时信息等等。因此，Python具备很强的动态性。
数 学 运算
Python使用与C、Java类似的运算符，支持整数与浮点数的数学 运算。同时还支持复数运算与无穷位数（实际受限于计算机的能力）的整数运算。除了求绝对值函数abs()外，大多数数学函数处于math和cmath模块内。前者用于实数运算，而后者用于复数运算。使用时需要先导入它们，比如：
>>>importmath>>>print(math.sin(math.pi/2))1.0
fractions模块用于支持分数运算；decimal模块用于支持高精度的浮点数运算。
Python定义求余运行a % b的值处于开区间[0, b)内，如果b是负数，开区间变为(b, 0]。这是一个很常见的定义方式。不过其实它依赖于整除的定义。为了让方程式：b * (a // b) + a % b = a恒真，整除运行需要向负无穷小方向取值。比如7 // 3的结果是2，而(-7) // 3的结果却是-3。这个算法与其它很多编程语言不一样，需要注意，它们的整除运算会向0的方向取值。
Python允许像数学的常用写法那样连着写两个比较运行符。比如a < b < c与a < b and b < c等价。C++的结果与Python不一样，首先它会先计算a < b，根据两者的大小获得0或者1两个值之一，然后再与c进行比较。
10 应用介绍 编辑
系统编程：提供API（Application Programming Interface应用程序编程接口），能方便进行系统维护和管理，Linux下标志性语言之一，是很多系统管理员理想的编程工具。
图形处理：有PIL、Tkinter等图形库支持，能方便进行图形处理。
数学处理：NumPy扩展提供大量与许多标准数学库的接口。
文本处理：python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。
数据库编程：程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，Mysql、SQLite等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。
网络编程：提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。很多大规模软件开发计划例如Zope，Mnet 及BitTorrent. Google都在广泛地使用它。
Web编程：应用的开发语言，支持最新的XML技术。
多媒体应用：Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。
pymo引擎：PYMO全称为python memories off，是一款运行于Symbian S60V3,Symbian3,S60V5, Symbian3, Android系统上的AVG游戏引擎。因其基于python2.0平台开发，并且适用于创建秋之回忆（memories off）风格的AVG游戏，故命名为PYMO。
黑客编程：python有一个hack的库,内置了你熟悉的或不熟悉的函数，但是缺少成就感。
用Python写简单爬虫
首先，要通过urllib2这个Module获得对应的HTML源码。
import urllib2
url='http://www。baidu。com/s?wd=cloga'
content=urllib2.urlopen(url).read()
通过上面这三句就可以将URL的源码存在content变量中，其类型为字符型。
接下来是要从这堆HTML源码中提取我们需要的内容。用Chrome查看一下对应的内容的代码（也可以用Firefox的Firebug）。
可以看到url的信息存储在span标签中，要获取其中的信息可以用正则式。
Pylons-Web应用框架
Zope- 应用服务器
Plone- 内容管理系统
Django- 鼓励快速开发的Web应用框架
Uliweb- 国人开发的轻量级Web框架
TurboGears- 另一个Web应用快速开发框架
Twisted--Python的网络应用程序框架
Python Wikipedia Robot Framework- MediaWiki的机器人程序
MoinMoinWiki- Python写成的Wiki程序
flask- Python 微Web框架
Webpy- Python 微Web框架
Bottle- Python 微Web框架
EVE- 网络游戏EVE大量使用Python进行开发
Reddit - 社交分享网站
Dropbox - 文件分享服务
Pylons - Web应用框架
TurboGears - 另一个Web应用快速开发框架
Fabric - 用于管理成百上千台Linux主机的程序库
Trac - 使用Python编写的BUG管理系统
Mailman - 使用Python编写的邮件列表软件
Mezzanine - 基于Django编写的内容管理系统系统
Blender - 以C与Python开发的开源3D绘图软件
11 工具功能 编辑
Tkinter
Python默认的图形界面接口。Tkinter是一个和Tk接口的Python模块，Tkinter库提供了对Tk API的接口，它属于Tcl/Tk的GUI工具组。
PyGTK
用于python GUI程序开发的GTK+库。GTK就是用来实现GIMP和Gnome的库。
PyQt
用于python的Qt开发库。QT就是实现了KDE环境的那个库，由一系列的模块组成，有qt, qtcanvas, qtgl, qtnetwork, qtsql, qttable, qtui and qtxml，包含有300个类和超过5750个的函数和方法。PyQt还支持一个叫qtext的模块，它包含一个QScintilla库。该库是Scintillar编辑器类的Qt接口。
wxPython
GUI编程框架，熟悉MFC的人会非常喜欢，简直是同一架构（对于初学者或者对设计要求不高的用户来说，使用Boa Constructor可以方便迅速的进行wxPython的开发）
PIL
python提供强大的图形处理的能力，并提供广泛的图形文件格式支持，该库能进行图形格式的转换、打印和显示。还能进行一些图形效果的处理，如图形的放大、缩小和旋转等。是Python用户进行图象处理的强有力工具。
Psyco
一个Python代码加速度器，可使Python代码的执行速度提高到与编译语言一样的水平。
xmpppy
Jabber服务器采用开发的XMPP协议，Google Talk也是采用XMPP协议的IM系统。在Python中有一个xmpppy模块支持该协议。也就是说，我们可以通过该模块与Jabber服务器通信，是不是很Cool。
PyMedia
用于多媒体操作的python模块。它提供了丰富而简单的接口用于多媒体处理(wav, mp3, ogg, avi, divx, dvd, cdda etc)。可在Windows和Linux平台下使用。
Pmw
Python megawidgets，Python超级GUI组件集，一个在python中利用Tkinter模块构建的高级GUI组件，每个Pmw都合并了一个或多个Tkinter组件，以实现更有用和更复杂的功能。
PyXML
用Python解析和处理XML文档的工具包，包中的4DOM是完全相容于W3C DOM规范的。它包含以下内容：
xmlproc: 一个符合规范的XML解析器。Expat: 一个快速的，非验证的XML解析器。还有其他和他同级别的还有 PyHtml PySGML。
PyGame
用于多媒体开发和游戏软件开发的模块。
PyOpenGL
模块封装了“OpenGL应用程序编程接口”，通过该模块python程序员可在程序中集成2D和3D的图形。
NumPy、NumArray、SAGE
NumArray是Python的一个扩展库，主要用于处理任意维数的固定类型数组，简单说就是一个矩阵库。它的底层代码使用C来编写，所以速度的优势很明显。SAGE是基于NumPy和其他几个工具所整合成的数学软件包，目标是取代Magma, Maple, Mathematica和Matlab 这类工具。
MySQLdb
用于连接MySQL数据库。还有用于zope的ZMySQLDA模块，通过它就可在zope中连接mysql数据库。
Sqlite3
用于连接sqlite数据库。
Python-ldap
提供一组面向对象的API，可方便地在python中访问ldap目录服务，它基于OpenLDAP2.x。
smtplib
发送电子邮件。
ftplib
定义了FTP类和一些方法，用以进行客户端的ftp编程。如果想了解ftp协议的详细内容，请参考RFC959。
12 版本介绍 编辑
[3]Python主要版本为2.x和3.x，目前2.x使用居多。这里有一篇关于“初学者学习python2还是python3？”的文章讲的很不错，可以参考一下：http://www.pythontab.com/html/2012/pythonjichu_1220/11.html
Python的3.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下兼容。许多针对早期Python版本设计的程序都无法在Python 3.0上正常运行。为了照顾现有程序，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。基于早期Python版本而能正常运行于Python 2.6并无警告的程序可以通过一个2 to 3的转换工具无缝迁移到Python 3.0。
新的Python程序建议使用Python 3.0版本的语法。除非运行环境无法安装Python 3.0或者程序本身使用了不支持Python 3.0的第三方库。目前不支持Python 3.0的第三方库有Django, Twisted, py2exe, PIL等。大多数第三方库都正在努力地兼容Python 3.0版本。即使无法立即使用Python 3.0，也建议编写兼容Python 3.0版本的程序，然后使用Python 2.6, Python 2.7来运行。Python 2.7被确定为最后一个Python 2.x版本，它除了支持Python 2.x语法外，还支持部分Python 3.1语法。
Python的3.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下兼容。许多针对早期Python版本设计的程序都无法在Python 3.0上正常运行。为了照顾现有程序，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。基于早期Python版本而能正常运行于Python 2.6并无警告的程序可以通过一个2 to 3的转换工具无缝迁移到Python 3.0。
新的Python程序建议使用Python 3.0版本的语法。除非运行环境无法安装Python 3.0或者程序本身使用了不支持Python 3.0的第三方库。不支持Python 3.0的第三方库有Django, Twisted, py2exe, PIL等。大多数第三方库都正在努力地兼容Python 3.0版本。即使无法立即使用Python 3.0，也建议编写兼容Python 3.0版本的程序，然后使用Python 2.6, Python 2.7来运行。Python 2.7被确定为最后一个Python 2.x版本，它除了支持Python 2.x语法外，还支持部分Python 3.1语法。
Python 3.0的变化主要在以下几个方面：
最引人注意的改变是print语句没有了，取而代之的是print()函数。可以使用2to3工具自动地转换print语句。Python 2.6与Python 2.7部分地支持这种形式的print语法。在Python 2.6与Python 2.7里面，以下三种形式是等价的：
print"fish"print("fish")#注意print后面有个空格print("fish")#print()不能带有任何其它参数
然而，Python 2.6实际已经支持新的print()语法。方法是：
from__future__import print_functionprint("fish","panda", sep=', ')
新的str类型表示一个Unicode字符串，相当于Python 2.x版本的unicode类型。而字节串行则用类似b"abc"的语法表示，用bytes类表示，相当于Python 2.x的str类型，两种类型不能再隐式地自动转换，因此在Python 3.x里面"fish"+b"panda"是错误。正确的写法是"fish"+b"panda".decode("utf-8")。Python 2.6可以自动地将字节串行识别为Unicode字符串，方法是：
from__future__import unicode_literalsprint(repr("fish"))
除法运算符/在Python 3.x内总是返回浮点数。而在Python 2.6内会判断被除数与除数是否是整数。如果是整数会返回整数值，相当于整除;浮点数则返回浮点数值。为了让Python 2.6统一返回浮点数值，可以：
from__future__import divisionprint(3/2)
捕获异常的语法由except exc, var改为except exc as var。使用语法except (exc1, exc2) as var可以同时捕获多种类型的异常。Python 2.6已经支持这两种语法。
字典推导式（Dictionary comprehensions）{expr1: expr2 for k, v in d}，这个语法等价于：
result={}for k, v in d.items(): result[expr1]=expr2return result
集合(set)的新写法：{1,2,3,4}。注意{}仍然表示空的字典(dict)。
八进制数必须写成0o777，原来的形式0777不能用了；二进制必须写成0b111。新增了一个bin()函数用于将一个整数转换成二进制字符串。Python 2.6已经支持这两种语法。
dict.keys(), dict.values(), dict.items(), map(), filter(), range(), zip()不再返回列表，而是迭代器。
如果两个对象之间没有定义明确的有意义的顺序。使用<, >, <=, >=比较它们会抛出异常。比如1 < ""在Python 2.6里面会返回True，而在Python 3.0里面会抛出异常。cmp(), instance.__cmp__()函数已经被删除。
可以注释函数的参数与返回值。此特性可方便IDE对源代码进行更深入的分析。例如：
def sendMail(from_:"nobody@example .com", \ to:"somebody@example .com", \ title:"hello", \ body:"Just say hello to you.") ->True: pass
根据PEP8，多个模块被改名：
旧的名字
新的名字
_winreg winreg
ConfigParser configparser
copy_reg copyreg
Queue queue
SocketServer socketserver
repr reprlib
StringIO模块被合并到新的io模块内。new, md5, gopherlib等模块被删除。Python 2.6已经支持新的io模块。
httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, Cookie, cookielib被合并到http包内。
取消了exec语句，只剩下exec()函数。Python 2.6已经支持exec()函数。
基本上，可以编写出使用Python 3.0语法并运行于Python 2.6, Python 2.7的程序。
13 开发环境 编辑
●IDLE：Python内置IDE (随python安装包提供)
●PyCharm：详见百度百科PyCharm，由著名的JetBrains公司开发，带有一整套可以帮助用户在使用Python语言开发时提高其效率的工 具，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。
●Komodo和Komodo Edit：后者是前者的免费精简版
●PythonWin：ActivePython或pywin32均提供该IDE，仅适用于Windows
●SPE（Stani's Python Editor）：功能较多的自由软件，基于wxPython
●Ulipad：功能较全的自由软件，基于wxPython；作者是中国Python高手limodou
●WingIDE：可能是功能最全的IDE，但不是自由软件(教育用户和开源用户可以申请免费key)
●Eric：基于PyQt的自由软件，功能强大。全名是：The Eric Python IDE
●DrPython
●PyScripter：使用Delphi开发的轻量级的开源Python IDE， 支持Python2.6和3.0。
●PyPE：一个开源的跨平台的PythonIDE。
●bpython： 类Unix操作系统下使用curses库开发的轻量级的Python解释器。语法提示功能。
●eclipse + pydev插件：方便调试程序
●emacs：自带python支持，自动补全、refactor等功能需要插件支持
●Vim: 最新7.3版编译时可以加入python支持，提供python代码自动提示支持
●Visual Studio 2003 + VisualPython：仅适用Windows，已停止维护，功能较差
●SlickEdit
●Visual Studio 2010 + Python Tools for Visual Studio
●TextMate
●Netbeans IDE
●Sublime
另外，诸如EditPlus、UltraEdit、PSPad等通用的程序员文本编辑器软件也能对Python代码编辑提供一定的支持，比如代码自动着色、注释快捷键等，但是否够得上集成开发环境的水平，尚有待评估。
14 其他相关 编辑
解释器
Python是一门跨平台的脚本语言，Python规定了一个Python语法规则，实现了Python语法的解释程序就成为了Python的解释器。
CPython（ClassicPython，也就是原始的Python实现，需要区别于其他实现的时候才以CPython称呼；或解作C语言实现的Python）。这是最常用的Python版本。
Jython（原名JPython；Java语言实现的Python，现已正式发布）。Jython可以直接调用Java的各种函数库。
PyPy（使用Python语言写的Python）
IronPython（面向.NET和ECMA CLI的Python实现）。IronPython能够直接调用.net平台的各种函数库。可以将Python程序编译成.net程序。
ZhPy（周蟒）（支持使用繁/简中文语句编写程序的Python语言）
学习网站
1．PythonTab中文网
2．Python爱好者论坛
3．Pythoner在线互动交流平台
4．一人一Python
参考资料：
1.
python简单介绍
2.
Python简介
3.
初学者学习python2还是python3
扩展阅读：
1.
Python介绍
2.
Python入门介绍
3.
详细说明Python工具介绍
词条标签：
编程语言 电脑 计算机 Python 开源
[ Last edited by zzz19760225 on 2016-9-22 at 17:35 ]
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
 2016-6-26 18:43 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
17 楼』:
MS-DOS 5.0内核剖析
出版: 西安电子科技大学出版社
分类: TP316
书号: 7-5606-0213-4
形态: 354 章节
全文目录
第九章 DOS核心文件的编程环境
1、1基本概念
1、1、1操作系统
目录
1、1、2操作系统分类
1、2操作系统的设计思想
1、2、1研究操作系统的几种观点
1、2、2操作系统结构设计方法
1、2、3层次结构法
1、2、4DOS设计思想
1、2、5DOS与其它操作系统的兼容性
1、3DOS发展概况
1、3、1DOS的历史
1、3、2DOS的未来
1、4DOS操作系统结构
1、4、1BIOS模块
1、4、2Kernel模块
1、4、3Shell模块
1、5DOS功能概述
2、1配置命令
2、1、1BREAK
2、1、2BUFFERS
2、1、3COMMENT
2、1、4COUNTRY
2、1、5DEVICE
2、1、6DEVICEHIGH
2、1、7DOS
2、1、8DRIVPARM
2、1、10FILES
2、1、9FCBS
2、1、11INSTALL
2、1、12LASTDRIVE
2、1、13MULTITRACK
2、1、14REM
2、1、15SHELL
2、1、16STACKS
2、1、17SWITCHES
2、2可安装的设备驱动程序
2、2、1ANSI.SYS
2、2、2DISPLAY.SYS
2、2、3DRIVER.SYS
2、2、4EGA.SYS
2、2、5EMM386.EXE
2、2、6HIMEM.SYS
2、2、7PRINTER.SYS
2、2、8RAMDRIVE.SYS
第一章 引论
2、2、10SMARTDRV.SYS
2、2、9SETVER.EXE
2、3代码页
2、3、1支持代码页的设备
2、3、2代码页定义
第二章 配置系统
2、3、3为什么要用代码页
2、3、4安装代码页
2、3、5代码页的转换
2、3、6显示当前的代码页
2、3、7刷新代码页
2、3、8代码页表
3、1DOS引导过程
3、1、1ROMBIOS启动
3、1、2DOS引导记录
第三章 DOS引导过程
3、1、3SysInt—Ⅰ
3、1、4DOSKernel模块的初始化程序
3、1、5SysInt—Ⅱ
3、1、6COMMAND初始化程序
3、2数据结构
3、2、1BPB参数块
3、2、2硬盘分区信息表
3、3引导程序的源程序注释清单
4、1设备分类
4、1、1字符设备
4、1、2块设备
4、2DOS设备
4、2、1控制器、适配器和接口
4、2、2设备的程序控制
4、2、3DOS支持的软盘类型
4、3数据结构
4、3、1磁盘参数表
4、3、2设备驱动程序标题
4、3、3设备驱动程序请求标题
4、3、4BIOS驱动器参数块
4、3、5DOS驱动器参数块
4、3、6盘缓冲区
4、4设备驱动程序的结构及调用格式
4、4、1设备驱动程序的结构
4、4、2设备驱动程序的调用格式
4、5设备驱动程序的编程与调试
4、5、1设备驱动程序的编程方法
4、5、2设备驱动程序的调试
5、1微机的内存结构
5、1、1常规内存
5、1、2扩充内存
5、1、3扩展内存
第四章 设备管理
5、1、4高内存块
5、1、5高内存区
5、1、6MS-DOS5.0提供的内存管理程序
5、1、7Lotus/Intel/Microsoft扩展内存规范
5、1、8Lotus/Intel/Microsoft/AST扩充内存规范
5、2DOS内存映象
5、2、1DOS内存约定
第五章 内存管理
5、2、2MS-DOS5.0内存映象
5、3数据结构
5、3、1内存控制块
5、3、2子段控制块
5、4内存管理程序的实现
5、4、1内存分配策略
5、4、2内存分配块的释放和修改
5、5准备更多的可用内存
5、5、1使用HIMEM.SYS扩充内存管理程序
5、5、2释放常规内存
5、5、3释放扩充内存
5、5、4释放扩展内存
5、6在高内存块中运行程序
5、6、1准备在高内存块运行程序
5、6、2为使用高内存块而设置CONFIG.SYS文件
5、6、3安装EMM386.EXE管理高内存块
5、6、4获取高内存块的信息
5、6、5将程序移入高内存块
5、6、6运行启动后分配内存的设备驱动程序
5、6、7在高内存块运行内存驻留程序
5、7结束并驻留TSR编程
5、7、1TSR程序的分类
5、7、2DOS操作系统的TSR程序
5、7、3DOS支持TSR程序的功能调用
5、7、4TSR程序的编程方法
6、1DOS文件系统的特点
6、1、1文件名
6、1、2文件类型
6、1、3通配符
6、1、4文件管理方法
6、1、5文件与设备的统一管理
6、1、6DOS文件系统的不足
6、2FAT文件系统的特点
6、2、1磁盘信息格式
6、2、2文件分配表
6、3目录结构
6、3、1树型目录结构
6、3、2树型目录使用的数据结构
6、3、3树型目录结构的管理
6、4文件管理的数据结构
6、4、1文件控制块
6、4、2文件句柄
6、4、3系统文件表
6、4、4文件共享的实现
6、4、5快速打开的实现
6、4、6文件系统的数据结构之间的关系
6、5读/写操作的实现
7、1可执行文件结构
7、1、1COM文件结构
第七章 进程管理
7、1、2EXE文件结构
7、2环境块
7、2、1环境块信息
7、2、2在批文件中使用环境变量
7、2、3扩展环境块空间
7、3程序段前缀
7、4EXEC功能调用的实现
7、5几个与PSP相关的功能调用
7、6进程终止
7、6、1进程终止时的公共处理
7、6、2正常终止
7、6、3驻留结束
7、6、4被零除错误（INT00H）处理
7、6、5Ctrl+C终止处理
7、6、6严重设备错误处理
8、001DOS功能调用一览表
8、002键盘功能调用一览表
8、003面向FCB的功能调用一览表
第八章 DOS功能调用
8、004面向文件句柄的功能调用一览表
8、005设备IOCTL的功能调用一览表
8、006国家语言支持（NLS）功能调用一览表
8、007内存管理功能调用一览表
8、008进程管理功能调用一览表
8、009网络功能调用一览表
8、010文件共享功能调用一览表
8、011目录管理功能调用一览表
8、012驱动器管理功能调用一览表
8、013系统功能调用一览表
8、014已被替代的功能调用一览表
8、01500H终止程序
第六章 文件系统
8、01601H带回显的控制台输入
8、01702H显示字符
8、01803H辅助输入
8、01904H辅助输出
8、02005H打印字符
8、02106H直接控制台I/O
8、02207H无回显的直接控制台输入
8、02308H无回显控制台输入
8、02409H显示字符串
8、0250AH缓冲键盘输入
8、0260BH检查键盘状态
8、0270CH清键盘缓冲区并读键盘
8、0280DH复位磁盘
8、0290EH设置缺省驱动器号
8、0300FH用FCB打开文件
8、03110H用FCB关闭文件
8、03211H用FCB查找第一个文件
8、03312H用FCB查找下一个文件
8、03413H用FCB删除文件
8、03514H用FCB顺序读
8、03615H用FCB顺序写
8、03716H用FCB创建文件
8、03817H用FCB更换文件名
8、03919H取缺省驱动器号
8、0401AH设置盘传送区地址
8、0411BH取缺省驱动器数据
8、0421CH取指定驱动器数据
8、0431FH取缺省驱动器的DDPB
8、04421H用FCB随机读
8、04522H用FCB随机写
8、04623H用FCB取文件大小
8、04724H设置随机记录号
8、04825H设置中断向量
8、04926H创建新程序段前缀
8、05027H用FCB随机块读
8、05128H用FCB随机块写
8、05229H分析文件名
8、0532AH取系统日期
8、0542BH设置系统日期
8、0552CH取系统时间
8、0562DH设置系统时间
8、0572EH设置/复位检验（VERIFY）标志
8、0582FH取盘传送区地址
8、05930H取DOS版本号
8、06031H结束并驻留
8、06132H取指定驱动器的DDPB
8、0623300H取Ctrl+C检查状态
8、0633301H设置Ctrl+C检查状态
8、0643302H取/置Ctrl+C检查状态
8、0653305H取引导驱动器号
8、0663306H取DOS版本号和DOS的安装位置
8、06734H取InDOS标志字节单元的地址
8、06835H取中断向量
8、06936H取磁盘自由空间
8、0703700H取开关前导字符
8、07138H取/置国家信息
8、07239H创建子目录
8、0733AH删除子目录
8、0743BH改变当前目录
8、0753CH创建文件
8、0763DH打开文件
8、0773EH关闭文件
8、0783FH读文件或设备
8、07940H写文件或设备
8、08041H删除文件
8、08142H移动文件读写指针
8、0824300H取文件属性
8、0834301H设置文件属性
8、0844400H取设备信息
8、0854401H设置设备信息
8、0864402H从字符设备读取控制数据
8、0874403H向字符设备发送控制数据
8、0884404H从块设备读取控制数据
8、0894405H向块设备发送控制数据
8、0904406H取输入状态
8、0914407H取输出状态
8、0924408H测试块设备是否支持介质装卸
8、0934409H测试逻辑驱动器是本地还是远程设备
8、094440AH测试文件句柄是对应于本地还是远程设备
8、095440BH设置共享重试计数
8、096440CH字符设备的类属IOCTL请求
8、097440DH块设备的类属IOCTL请求
8、098440EH取逻辑驱动器映象
8、099440FH设置逻辑驱动器映象
8、1004410H字符设备的类属IOCTL查询
8、1014411H块设备的类属IOCTL查询
8、10245H复制文件句柄
8、10346H强迫复制文件句柄
8、10447H取当前目录
8、10548H分配内存
8、10649H释放分配的内存块
8、1074AH修改分配的内存块
8、1084B00H装入并执行程序
8、1094B01H装入程序
8、1104B03H装入覆盖
8、1114B05H设置执行状态
8、1124CH结束进程
8、1134DH取子进程的返回码
8、1144EH查找第一个文件
8、1154FH查找下一个文件
8、11650H设置活动进程的PSP段地址
8、11751H取当前活动进程的PSP段地址
8、11852H取DOS多重表指针值
8、11953H根据BPB参数块内容设置DDPB
8、12054H取检验状态
8、12155H创建程序段前缀
8、12256H更换文件名
8、1235700H取文件的日期和时间
8、1245701H设置文件的日期和时间
8、1255800H取内存分配策略
8、1265801H设置内存分配策略
8、1275802H取UMB联接状态
8、1285803H设置UMB联接状态
8、12959H取扩充错误信息
8、1305AH创建临时文件
8、1315BH创建新文件
8、1325CH锁定/开锁文件
8、1335D00H服务器功能调用
8、1345D01H提交所有文件
8、1355D02H以名字关闭共享文件
8、1365D03H关闭指定计算机的所有共享文件
8、1375D04H关闭指定计算机的特定进程的所有共享文件
8、1385D05H取共享文件的信息
8、1395D06H取DOS数据交换区的地址
8、1405D07H取打印流状态
8、1415D08H设置打印流状态
8、1425D09H截断打印流
8、1435D0AH设置扩充错误信息
8、1445E00H取机器名
8、1455E01H设置机器名
8、1465E02H设置打印机配置
8、1475E03H取打印机配置
8、1485E04H设置打印机模式
8、1495E05H取打印机模式
8、1505F00H取重定向模式
8、1515F01H设置重定向模式
8、1525F02H取重定向列表项
8、1535F03H重定向设备
8、1545F04H取消重定向
8、15560H规范化文件名
8、15662H取当前活动进程的PSP段地址
8、1576300H取DBCS引导字节表地址
8、1586501H取全国家信息表
8、1596502H/6504H取文本/文件名大写表地址
8、1606505H取文件名字符表地址
8、1616506H取对照表地址
8、1626507H取DBCS向量表地址
8、1636520H字符变大写
8、1646521H字符串变大写
8、1656522HASCIIZ字符串变大写
8、1666523H字符Yes或No检查
8、16766H取/置全局代码页
8、16867H设置文件句柄数
8、16968H/6AH提交文件
8、17069H取/置介质ID
8、1716CH扩充的打开/创建文件
8、172DOS扩充错误码表
8、173DOS扩充错误类型表
8、174DOS建议采取的措施表
8、175DOS扩充错误位置表
9、1硬件环境
9、1、1几个新增加的CPU指令
9、1、2实时时钟/CMOSRAM
9、2中断系统
9、2、1中断分类
9、2、2DOS保留中断
9、2、3DOS专用中断
9、2、4DOS可调用中断
10、1IO.SYS的编程基础
10、2IO.SYS的组成
目录
10、3IO.SYS的各个模块的功能
10、3、1Loader模块
第十章 IO.SYS源程序
10、3、2IO1模块
10、3、3IO2模块
10、3、4IO3模块
10、4IO.SYS源程序注释清单
10、4、1IO.SYS源程序的编译和连接方式
10、4、2BIO.STR的源程序清单
10、4、3Loader模块的源程序注释清单
10、4、4IO1模块的源程序注释清单
10、4、5IO2模块的源程序注释清单
10、4、6IO3模块的源程序注释清单
10、5IO.SYS源程序索引
10、5、1IO.SYS源程序的过程名索引
10、5、2IO.SYS源程序的变量名索引
11、1MSDOS.SYS的编程基础
11、2MSDOS.SYS的组成
目录
11、2、1MSDOS1模块
第十一章 MSDOS.SYS源程序
11、2、2MSDOS2模块
11、3MSDOS.SYS源程序注释清单
11、3、1MSDOS.SYS源程序的编译和连接方式
11、3、2DOS.STR的源程序清单
11、3、3MSDOS1模块的源程序注释清单
11、3、4MSDOS2模块的源程序注释清单
11、3、5INIT模块的源程序注释清单
11、4MSDOS.SYS源程序索引
11、4、1MSDOS.SYS源程序的过程名索引
11、4、2MSDOS.SYS源程序的变量名索引
[ Last edited by zzz19760225 on 2017-6-12 at 04:38 ]
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 18:44 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
18 楼』:
MUD LPC
LPC语言 编辑
本词条缺少名片图，补充相关内容使词条更完整，还能快速升级，赶紧来编辑吧！
LPC语言是由Lars Pensjǒ在1989年根据C语言开发的编程语言，主要是用来编写MUD游戏，使用LPC语言开发的MUD游戏被称为LPMUD。
中文名 LPC语言 外文名 Lars Pensjǒ C 开发时间 1989年 开发者 Lars Pensjǒ
目录
1 简介
2 LPC的函数分类
简介编辑
LPC类似C语言，语法大致相同，文件扩展名也为“.c”。不过LPC 是一面向对象语言，有对象（Object），但又没有类（class）的概念。和C语言相比LPC没有main()函数，但有一个create()函数，在对象载入时自动调用以完成初始化。
LPC是文字MUD游戏的编程语言，这类MUD统称LPMUD，多为解迷型，国类所有武侠MUD和神话MUD都是LPMUD。
Lpc的程序看起来和一般的C区别不大，语法基本一样，但是Lpc和一般的语言有着根本的不同，Lpc程序是编写一个一个的"Object"。这有什么区别呢？一般的程序是在执行过程中，通常有一个明显的开始和和结束，程序从一个地方开始，然后顺序执行下去，到了结束的地方就中断了。Lpc的Object不是这样的，所谓的不同的Mud，实际上是一些不同的Lpc的Object在一个Driver的上的各种不同的表现。也就说，Lpc的Object是运行在一个Driver上的，这些Object组成了LpMud的丰富多彩的世界。
例子：如果你想在MUD中加一个地区，就在该地区目录中新建一个文件。
inherit ROOM;
void create()
{
set("short", "客店二楼");
set("long", @LONG
你正走在客店二楼的走廊上，可以听到从客房里不时地呼呼的打酣声，一阵
高过一阵。不时有睡意朦胧的旅客进进出出，到楼下的掌柜处付了钱再上来睡觉。
LONG );
set("exits", ([
"down" : "/d/city/kedian",
"enter" : "/d/city/kedian3",
]));
setup();
replace_program(ROOM);
}
然后更新这个文件并在在其它地区加上这个地点的入口就可以到达了，MUD的世界就是很多这种地点的连接。
LPC的函数分类编辑
LPC语言的函数可分为以下4类：
⒈apply
在MUDLIB中定义的只能被游戏驱动（MUDOS）呼叫的函数，所有applies也都是lfuns。
⒉efun (external function)
外部函数（相对于MUDLIB定义的函数来说），也就是定义在游戏驱动中的函数。因为是直接定义在游戏驱动中，所以运行速度更快。
⒊lfun (local function)
本地函数，MUDLIB的object中自己定义的函数，为什么applies也属于lfun？因为这些函数内容也是你自己写的。
⒋sefun (simulated external function)
模拟外部函数，本质上是本地函数，但多数是把efun做了重写，这类函数属于MUDLIB的核心。
[ Last edited by zzz19760225 on 2017-6-16 at 12:47 ]
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 18:44 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
19 楼』:
1警告 非可移动函数指针任务在函数：main initgraph(640*480);
错误 太少的参数在调用'initgraph'在函数:main
[ Last edited by zzz19760225 on 2017-8-17 at 09:35 ]
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 18:50 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
|
|
2016-6-26 18:52 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
|
|
2016-6-26 18:56 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
22 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 18:57 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
23 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:00 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
24 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:02 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
25 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:03 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
26 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:07 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
27 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:07 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
28 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:09 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
29 楼』:
1
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:10 |
|
|
zzz19760225
超级版主
积分 3673
发帖 2020
注册 2016-2-1
状态 离线
|
『第
30 楼』:
http://www.huzheng.org/showartic ... &&newsid=24
星际译王(StarDict)的2.4.6版新增加了Windows下屏幕取词的功能。在开发这个功能时参考了Mueller Electronic Dicionary(一个用Delphi编的词典软件)的源代码，以及网上的文档。开发语言是C，用Dev-cpp编译。
这个功能现在还不太完善，目前有以下问题：
1. 在Win2k系统下，对桌面上的英文取词时为乱码。Windows XP则没有问题。
2. 在标题栏，开始菜单及IE, FireFox, Opear等软件上取词时，获取的Y坐标值不正确。见源码包里的src/win32/TextOutHook.c的IsInsidePointW()里的注释。
3. cmd.exe(命令提示符)无法取词。见源码包里的src/win32/GetWord.c的RemoteExecute()里的注释。
4. Adobe Reader无法取词。可能要像金山词霸那样编个Adobe Reader的插件。
希望高手能帮忙解决。
现在把完整源代码贴到这里：
TextOutSpy.c
=============================
#include "TextOutSpy.h"
#include "ThTypes.h"
const int MOUSEOVER_INTERVAL = 300;
const int WM_MY_SHOW_TRANSLATION = WM_USER + 300;
HINSTANCE g_hInstance = NULL;
HANDLE hSynhroMutex = 0;
HINSTANCE hGetWordLib = 0;
typedef void (*GetWordProc_t)(TCurrentMode *);
GetWordProc_t GetWordProc = NULL;
static void SendWordToServer()
{
if (hGetWordLib == 0) {
hGetWordLib = LoadLibrary(GlobalData->LibName);
if (hGetWordLib) {
GetWordProc = (GetWordProc_t)GetProcAddress(hGetWordLib, "GetWord");
}
else {
hGetWordLib = (HINSTANCE)-1;
}
}
if (GetWordProc) {
GlobalData->CurMod.WND = GlobalData->LastWND;
GlobalData->CurMod.Pt = GlobalData->LastPt;
GetWordProc(&(GlobalData->CurMod));
if (GlobalData->CurMod.WordLen > 0) {
DWORD SendMsgAnswer;
SendMessageTimeout(GlobalData->ServerWND, WM_MY_SHOW_TRANSLATION, 0, 0, SMTO_ABORTIFHUNG, MOUSEOVER_INTERVAL, &SendMsgAnswer);
}
}
}
void CALLBACK TimerFunc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime)
{
if (WaitForSingleObject(hSynhroMutex, 0) == WAIT_OBJECT_0) {
if (GlobalData->TimerID) {
if (KillTimer(0, GlobalData->TimerID))
GlobalData->TimerID=0;
}
ReleaseMutex(hSynhroMutex);
}
if ((GlobalData->LastWND!=0)&&(GlobalData->LastWND == WindowFromPoint(GlobalData->LastPt))) {
if (WaitForSingleObject(hSynhroMutex, 0) == WAIT_OBJECT_0) {
SendWordToServer();
ReleaseMutex(hSynhroMutex);
}
}
}
LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
if ((nCode == HC_ACTION) && ((wParam == WM_MOUSEMOVE) || (wParam == WM_NCMOUSEMOVE))) {
if (WaitForSingleObject(hSynhroMutex, 0) == WAIT_OBJECT_0) {
if (GlobalData->TimerID) {
if (KillTimer(0, GlobalData->TimerID))
GlobalData->TimerID=0;
}
HWND WND = WindowFromPoint(((PMOUSEHOOKSTRUCT)lParam)->pt);
TCHAR wClassName[64];
if (GetClassName(WND, wClassName, sizeof(wClassName) / sizeof(TCHAR))) {
const char* DisableClasses[] = {
"gdkWindowChild",
"gdkWindowTemp",
};
int i;
for (i=0; i<2; i++) {
if (strcmp(wClassName, DisableClasses)==0)
break;
}
if (i<2) {
ReleaseMutex(hSynhroMutex);
return CallNextHookEx(GlobalData->g_hHookMouse, nCode, wParam, lParam);
}
}
GlobalData->TimerID = SetTimer(0, 0, MOUSEOVER_INTERVAL, TimerFunc);
GlobalData->LastWND = WND;
GlobalData->LastPt = ((PMOUSEHOOKSTRUCT)lParam)->pt;
ReleaseMutex(hSynhroMutex);
}
}
return CallNextHookEx(GlobalData->g_hHookMouse, nCode, wParam, lParam);
}
DLLIMPORT void ActivateTextOutSpying (int Activate)
{
// After call SetWindowsHookEx(), when you move mouse to a application's window,
// this dll will load into this application automatically. And it is unloaded
// after call UnhookWindowsHookEx().
if (Activate) {
if (GlobalData->g_hHookMouse != NULL) return;
GlobalData->g_hHookMouse = SetWindowsHookEx(WH_MOUSE, MouseHookProc, g_hInstance, 0);
}
else {
if (GlobalData->g_hHookMouse == NULL) return;
if (WaitForSingleObject(hSynhroMutex, 0) == WAIT_OBJECT_0) {
if (GlobalData->TimerID) {
if (KillTimer(0, GlobalData->TimerID))
GlobalData->TimerID=0;
}
ReleaseMutex(hSynhroMutex);
}
UnhookWindowsHookEx(GlobalData->g_hHookMouse);
GlobalData->g_hHookMouse = NULL;
}
}
BOOL APIENTRY DllMain (HINSTANCE hInst /* Library instance handle. */ ,
DWORD reason /* Reason this function is being called. */ ,
LPVOID reserved /* Not used. */ )
{
switch (reason)
{
case DLL_PROCESS_ATTACH:
g_hInstance = hInst;
hSynhroMutex = CreateMutex(NULL, FALSE, "StarDictTextOutSpyMutex");
ThTypes_Init();
break;
case DLL_PROCESS_DETACH:
WaitForSingleObject(hSynhroMutex, INFINITE);
if (GlobalData->TimerID) {
if (KillTimer(0, GlobalData->TimerID))
GlobalData->TimerID=0;
}
ReleaseMutex(hSynhroMutex);
CloseHandle(hSynhroMutex);
{
MSG msg ;
while (PeekMessage (&msg, 0, WM_TIMER, WM_TIMER, PM_REMOVE)) {}
}
if ((hGetWordLib != 0)&&(hGetWordLib != (HINSTANCE)(-1))) {
FreeLibrary(hGetWordLib);
}
Thtypes_End();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
/* Returns TRUE on success, FALSE on failure */
return TRUE;
}
=============================
TextOutSpy.h
=============================
#ifndef _TextOutSpy_H_
#define _TextOutSpy_H_
#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */
DLLIMPORT void ActivateTextOutSpying (int Activate);
#endif /* _TextOutSpy_H_ */
=============================
ThTypes.c
=============================
#include "ThTypes.h"
HANDLE MMFHandle = 0;
TGlobalDLLData *GlobalData = NULL;
void ThTypes_Init()
{
if (!MMFHandle)
MMFHandle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, sizeof(TGlobalDLLData), "StarDictTextOutHookSharedMem");
if (!GlobalData)
GlobalData = MapViewOfFile(MMFHandle, FILE_MAP_ALL_ACCESS, 0, 0, 0);
}
void Thtypes_End()
{
if (GlobalData) {
UnmapViewOfFile(GlobalData);
GlobalData = NULL;
}
if (MMFHandle) {
CloseHandle(MMFHandle);
MMFHandle = 0;
}
}
=============================
ThTypes.h
=============================
#ifndef _ThTypes_H_
#define _ThTypes_H_
#include <windows.h>
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef struct TCurrentMode {
HWND WND;
POINT Pt;
int WordLen;
char MatchedWord[256];
int BeginPos;
} TCurrentMode;
typedef struct TGlobalDLLData {
HWND ServerWND;
HHOOK g_hHookMouse;
DWORD TimerID;
HWND LastWND;
POINT LastPt;
TCurrentMode CurMod;
char LibName[256];
} TGlobalDLLData;
extern TGlobalDLLData *GlobalData;
void ThTypes_Init();
void Thtypes_End();
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
=============================
TextOutHook.c
=============================
#include "TextOutHook.h"
#include "GetWord.h"
#include "HookImportFunction.h"
typedef BOOL WINAPI (*TextOutANextHook_t)(HDC hdc, int nXStart, int nYStart, LPCSTR lpszString,int cbString);
TextOutANextHook_t TextOutANextHook = NULL;
typedef BOOL WINAPI (*TextOutWNextHook_t)(HDC hdc, int nXStart, int nYStart, LPCWSTR lpszString,int cbString);
TextOutWNextHook_t TextOutWNextHook = NULL;
typedef BOOL WINAPI (*ExtTextOutANextHook_t)(HDC hdc, int nXStart, int nYStart, UINT fuOptions, CONST RECT *lprc, LPCSTR lpszString, UINT cbString, CONST INT *lpDx);
ExtTextOutANextHook_t ExtTextOutANextHook = NULL;
typedef BOOL WINAPI (*ExtTextOutWNextHook_t)(HDC hdc, int nXStart, int nYStart, UINT fuOptions, CONST RECT *lprc, LPCWSTR lpszString, UINT cbString, CONST INT *lpDx);
ExtTextOutWNextHook_t ExtTextOutWNextHook = NULL;
typedef struct TEverythingParams {
HWND WND;
POINT Pt;
int Active;
int WordLen;
int Unicode;
int BeginPos;
char MatchedWordA[256];
wchar_t MatchedWordW[256];
} TEverythingParams;
TEverythingParams *CurParams = NULL;
static void ConvertToMatchedWordA(TEverythingParams *TP)
{
if (TP->Unicode) {
if (TP->WordLen>0) {
int BeginPos = TP->BeginPos;
TP->BeginPos = WideCharToMultiByte(CP_ACP, 0, TP->MatchedWordW, BeginPos, TP->MatchedWordA, sizeof(TP->MatchedWordA)-1, NULL, NULL);
TP->WordLen = WideCharToMultiByte(CP_ACP, 0, TP->MatchedWordW + BeginPos, TP->WordLen - BeginPos, TP->MatchedWordA + TP->BeginPos, sizeof(TP->MatchedWordA)-1 - TP->BeginPos, NULL, NULL);
TP->WordLen += TP->BeginPos;
TP->MatchedWordA[TP->WordLen] = '\0';
} else {
TP->MatchedWordA[0] = '\0';
}
TP->Unicode = FALSE;
} else {
TP->MatchedWordA[TP->WordLen] = '\0';
}
}
static int MyCopyMemory(char *a, const char *b, int len)
{
int count = 0;
int i;
for (i=0; ix) && (p->x<=rec.right) && (rec.top<=p->y) && (p->y<=rec.bottom)) {
ZeroMemory(&info, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_TYPE | MIIM_SUBMENU;
info.cch = 256;
info.dwTypeData = malloc(256);
GetMenuItemInfo(menu, i, TRUE, &info);
if (info.cch>0) {
if (info.cch > 255)
CurParams->WordLen = 255;
else
CurParams->WordLen = info.cch;
CurParams->Unicode = FALSE;
CurParams->WordLen = MyCopyMemory(CurParams->MatchedWordA, info.dwTypeData, CurParams->WordLen);
CurParams->BeginPos = 0;
}
free(info.dwTypeData);
}
}
}
static void GetWordTextOutHook (TEverythingParams *TP)
{
CurParams = TP;
ScreenToClient(TP->WND, &(TP->Pt));
if (TP->Pt.y<0) {
char buffer[256];
GetWindowText(TP->WND, buffer, sizeof(buffer)-1);
CurParams->Active = TRUE;
SetWindowText(TP->WND, buffer);
CurParams->Active = FALSE;
HMENU menu = GetMenu(TP->WND);
if (menu) {
ClientToScreen(TP->WND, &(TP->Pt));
IterateThroughItems(TP->WND, menu, &(TP->Pt));
}
}
else {
RECT UpdateRect;
GetClientRect(TP->WND, &UpdateRect);
UpdateRect.top = TP->Pt.y;
UpdateRect.bottom = TP->Pt.y + 1;
CurParams->Active = TRUE;
InvalidateRect(TP->WND, &UpdateRect, FALSE);
UpdateWindow(TP->WND);
CurParams->Active = FALSE;
}
CurParams = NULL;
}
char* ExtractFromEverything(HWND WND, POINT Pt, int *BeginPos)
{
TEverythingParams CParams;
ZeroMemory(&CParams, sizeof(CParams));
CParams.WND = WND;
CParams.Pt = Pt;
GetWordTextOutHook(&CParams);
ConvertToMatchedWordA(&CParams);
*BeginPos = CParams.BeginPos;
return strdup(CParams.MatchedWordA);
}
static void IsInsidePointA(const HDC DC, int X, int Y, LPCSTR Str, int Count)
{
SIZE Size;
if ((Count > 0) && GetTextExtentPoint32A(DC, Str, Count, &Size)) {
DWORD Flags = GetTextAlign(DC);
POINT Pt;
if (Flags & TA_UPDATECP) {
GetCurrentPositionEx(DC, &Pt);
} else {
Pt.x = X;
Pt.y = Y;
}
if (Flags & TA_CENTER) {
Pt.x-=(Size.cx/2);
} else if (Flags & TA_RIGHT) {
Pt.x-=Size.cx;
}
if (Flags & TA_BASELINE) {
TEXTMETRIC tm;
GetTextMetricsA(DC, &tm);
Pt.y-=tm.tmAscent;
} else if (Flags & TA_BOTTOM) {
Pt.y-=Size.cy;
}
LPtoDP(DC, &Pt, 1);
RECT Rect;
Rect.left = Pt.x;
Rect.right = Pt.x + Size.cx;
Rect.top = Pt.y;
Rect.bottom = Pt.y + Size.cy;
if (((Rect.left <= Rect.right) && (CurParams->Pt.x >= Rect.left) && (CurParams->Pt.x <= Rect.right)) ||
((Rect.left > Rect.right) && (CurParams->Pt.x <= Rect.left) && (CurParams->Pt.x >= Rect.right))) {
//if (PtInRect(&Rect, CurParams->Pt)) {
CurParams->Active = !PtInRect(&Rect, CurParams->Pt);
//CurParams->Active = FALSE;
int BegPos = round(abs((CurParams->Pt.x - Rect.left) / (Rect.right - Rect.left)) * (Count - 1));
while ((BegPos < Count - 1) && GetTextExtentPoint32A(DC, Str, BegPos + 1, &Size) && (Size.cx < CurParams->Pt.x - Rect.left))
BegPos++;
while ((BegPos >= 0) && GetTextExtentPoint32A(DC, Str, BegPos + 1, &Size) && (Size.cx > CurParams->Pt.x - Rect.left))
BegPos--;
if (BegPos < Count - 1)
BegPos++;
CurParams->BeginPos = BegPos;
if (Count > 255)
CurParams->WordLen = 255;
else
CurParams->WordLen = Count;
CurParams->Unicode = FALSE;
CopyMemory(CurParams->MatchedWordA, Str, CurParams->WordLen);
}
}
}
static void IsInsidePointW(const HDC DC, int X, int Y, LPCWSTR Str, int Count)
{
SIZE Size;
if ((Count > 0) && GetTextExtentPoint32W(DC, Str, Count, &Size)) {
DWORD Flags = GetTextAlign(DC);
POINT Pt;
if (Flags & TA_UPDATECP) {
GetCurrentPositionEx(DC, &Pt);
} else {
Pt.x = X;
Pt.y = Y;
}
if (Flags & TA_CENTER) {
Pt.x-=(Size.cx/2);
} else if (Flags & TA_RIGHT) {
Pt.x-=Size.cx;
}
if (Flags & TA_BASELINE) {
TEXTMETRICW tm;
GetTextMetricsW(DC, &tm);
Pt.y-=tm.tmAscent;
} else if (Flags & TA_BOTTOM) {
Pt.y-=Size.cy;
}
LPtoDP(DC, &Pt, 1);
RECT Rect;
Rect.left = Pt.x;
Rect.right = Pt.x + Size.cx;
Rect.top = Pt.y;
Rect.bottom = Pt.y + Size.cy;
// Bug: We don't check Pt.y here, as don't call PtInRect() directly, because
// in Title bar, Start Menu, IE, FireFox, Opera etc., the Rect.top and Rect.bottom will be wrong.
// I try to use GetDCOrgEx(DC, &Pt), but they are not normal HDC that Pt.x and Pt.y will equal to 0 in these cases.
// And use GetWindowRect() then get Rect.left and Rect.top is only useful on Title bar.
if (((Rect.left <= Rect.right) && (CurParams->Pt.x >= Rect.left) && (CurParams->Pt.x <= Rect.right)) ||
((Rect.left > Rect.right) && (CurParams->Pt.x <= Rect.left) && (CurParams->Pt.x >= Rect.right))) {
//if (PtInRect(&Rect, CurParams->Pt)) {
CurParams->Active = !PtInRect(&Rect, CurParams->Pt);
//CurParams->Active = FALSE;
int BegPos = round(abs((CurParams->Pt.x - Rect.left) / (Rect.right - Rect.left)) * (Count - 1));
while ((BegPos < Count - 1) && GetTextExtentPoint32W(DC, Str, BegPos + 1, &Size) && (Size.cx < CurParams->Pt.x - Rect.left))
BegPos++;
while ((BegPos >= 0) && GetTextExtentPoint32W(DC, Str, BegPos + 1, &Size) && (Size.cx > CurParams->Pt.x - Rect.left))
BegPos--;
if (BegPos < Count - 1)
BegPos++;
CurParams->BeginPos = BegPos;
if (Count > 255)
CurParams->WordLen = 255;
else
CurParams->WordLen = Count;
CurParams->Unicode = TRUE;
CopyMemory(CurParams->MatchedWordW, Str, CurParams->WordLen * sizeof(wchar_t));
}
}
}
BOOL WINAPI TextOutACallbackProc(HDC hdc, int nXStart, int nYStart, LPCSTR lpszString, int cbString)
{
if (CurParams && CurParams->Active)
IsInsidePointA(hdc, nXStart, nYStart, lpszString, cbString);
return TextOutANextHook(hdc, nXStart, nYStart, lpszString, cbString);
}
BOOL WINAPI TextOutWCallbackProc(HDC hdc, int nXStart, int nYStart, LPCWSTR lpszString, int cbString)
{
if (CurParams && CurParams->Active)
IsInsidePointW(hdc, nXStart, nYStart, lpszString, cbString);
return TextOutWNextHook(hdc, nXStart, nYStart, lpszString, cbString);
}
BOOL WINAPI ExtTextOutACallbackProc(HDC hdc, int nXStart, int nYStart, UINT fuOptions, CONST RECT *lprc, LPCSTR lpszString, UINT cbString, CONST INT *lpDx)
{
if (CurParams && CurParams->Active)
IsInsidePointA(hdc, nXStart, nYStart, lpszString, cbString);
return ExtTextOutANextHook(hdc, nXStart, nYStart, fuOptions, lprc, lpszString, cbString, lpDx);
}
BOOL WINAPI ExtTextOutWCallbackProc(HDC hdc, int nXStart, int nYStart, UINT fuOptions, CONST RECT *lprc, LPCWSTR lpszString, UINT cbString, CONST INT *lpDx)
{
if (CurParams && CurParams->Active)
IsInsidePointW(hdc, nXStart, nYStart, lpszString, cbString);
return ExtTextOutWNextHook(hdc, nXStart, nYStart, fuOptions, lprc, lpszString, cbString, lpDx);
}
static void InstallTextOutHooks()
{
HookAPI("gdi32.dll", "TextOutA", (PROC)TextOutACallbackProc, (PROC*)&TextOutANextHook);
HookAPI("gdi32.dll", "TextOutW", (PROC)TextOutWCallbackProc, (PROC*)&TextOutWNextHook);
HookAPI("gdi32.dll", "ExtTextOutA", (PROC)ExtTextOutACallbackProc, (PROC*)&ExtTextOutANextHook);
HookAPI("gdi32.dll", "ExtTextOutW", (PROC)ExtTextOutWCallbackProc, (PROC*)&ExtTextOutWNextHook);
}
static void UninstallTextOutHooks()
{
if (TextOutANextHook)
HookAPI("gdi32.dll", "TextOutA", (PROC)TextOutANextHook, NULL);
if (TextOutWNextHook)
HookAPI("gdi32.dll", "TextOutW", (PROC)TextOutWNextHook, NULL);
if (ExtTextOutANextHook)
HookAPI("gdi32.dll", "ExtTextOutA", (PROC)ExtTextOutANextHook, NULL);
if (ExtTextOutWNextHook)
HookAPI("gdi32.dll", "ExtTextOutW", (PROC)ExtTextOutWNextHook, NULL);
}
DLLIMPORT void GetWord (TCurrentMode *P)
{
TCHAR wClassName[64];
if (GetClassName(P->WND, wClassName, sizeof(wClassName) / sizeof(TCHAR))==0)
wClassName[0] = '\0';
TKnownWndClass WndClass = GetWindowType(P->WND, wClassName);
char *p = TryGetWordFromAnyWindow(WndClass, P->WND, P->Pt, &(P->BeginPos));
if (p) {
P->WordLen = strlen(p);
strcpy(P->MatchedWord, p);
free(p);
} else {
P->WordLen = 0;
}
}
BOOL APIENTRY DllMain (HINSTANCE hInst /* Library instance handle. */ ,
DWORD reason /* Reason this function is being called. */ ,
LPVOID reserved /* Not used. */ )
{
switch (reason)
{
case DLL_PROCESS_ATTACH:
//ThTypes_Init();
InstallTextOutHooks();
break;
case DLL_PROCESS_DETACH:
UninstallTextOutHooks();
//Thtypes_End();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}
/* Returns TRUE on success, FALSE on failure */
return TRUE;
}
=============================
TextOutHook.h
=============================
#ifndef _TextOutHook_H_
#define _TextOutHook_H_
#if BUILDING_DLL
# define DLLIMPORT __declspec (dllexport)
#else /* Not BUILDING_DLL */
# define DLLIMPORT __declspec (dllimport)
#endif /* Not BUILDING_DLL */
#include "ThTypes.h"
char* ExtractFromEverything(HWND WND, POINT Pt, int *BeginPos);
DLLIMPORT void GetWord (TCurrentMode *P);
#endif /* _TextOutHook_H_ */
=============================
GetWord.c
=============================
#include "GetWord.h"
#include "TextOutHook.h"
TKnownWndClass GetWindowType(HWND WND, const char* WNDClass)
{
const char* StrKnownClasses[] = {
"RICHEDIT20A",
"RICHEDIT20W",
"RICHEDIT",
"EDIT",
"INTERNET EXPLORER_SERVER",
"CONSOLEWINDOWCLASS", // NT
"TTYGRAB", // 9x
};
TKnownWndClass KnownClasses[] = {
kwcRichEdit,
kwcRichEdit,
kwcRichEdit,
kwcMultiLineEdit,
kwcInternetExplorer_Server,
kwcConsole,
kwcConsole,
};
int i;
for (i=0; i<7; i++) {
if (strcasecmp(WNDClass, StrKnownClasses)==0)
break;
}
if (i<7) {
if (KnownClasses == kwcMultiLineEdit) {
if ((GetWindowLong(WND, GWL_STYLE) & ES_MULTILINE) == 0)
return kwcSingleLineEdit;
}
return KnownClasses;
} else
return kwcUnknown;
}
static char* ExtractWordFromRichEditPos(HWND WND, POINT Pt, int *BeginPos)
{
return ExtractFromEverything(WND, Pt, BeginPos);
}
/*
typedef struct TEditParams {
HWND WND;
POINT Pt;
char Buffer[256];
} TEditParams;
static int ExtractWordFromEditPosPack(TEditParams *params)
{
int Result = 0;
int BegPos;
BegPos = SendMessage(params->WND, EM_CHARFROMPOS, 0, params->Pt.x | params->Pt.y << 16);
if (BegPos == -1)
return Result;
int MaxLength;
MaxLength = SendMessage(params->WND, EM_LINELENGTH, BegPos & 0xFFFF, 0);
if (MaxLength <= 0)
return Result;
char *Buf;
Buf = GlobalAlloc(GMEM_FIXED, MaxLength + 1);
if (Buf) {
*Buf = MaxLength;
MaxLength = SendMessage(params->WND, EM_GETLINE, BegPos >> 16, (int)Buf);
Buf[MaxLength] = '\0';
BegPos = (BegPos & 0xFFFF) - SendMessage(params->WND, EM_LINEINDEX, BegPos >> 16, 0) - 1;
int EndPos;
EndPos = BegPos;
while ((BegPos >= 0) && IsCharAlpha(Buf[BegPos]))
BegPos--;
while ((EndPos < MaxLength) && IsCharAlpha(Buf[EndPos]))
EndPos++;
MaxLength = EndPos - BegPos - 1;
if (MaxLength >= 0) {
if (255 >= MaxLength) {
Buf[EndPos] = '\0';
lstrcpy(params->Buffer, Buf + BegPos + 1);
Result = MaxLength;
}
}
GlobalFree(Buf);
}
return Result;
}
*/
static char* ExtractWordFromEditPos(HWND hEdit, POINT Pt, int *BeginPos)
{
return ExtractFromEverything(hEdit, Pt, BeginPos);
/* TEditParams *TP;
TP = malloc(sizeof(TEditParams));
TP->WND = hEdit;
TP->Pt = Pt;
TP->Buffer[0] = '\0';
ScreenToClient(hEdit, &(TP->Pt));
int MaxLength;
MaxLength = ExtractWordFromEditPosPack(TP);
char *Result;
if (MaxLength>0) {
Result = strdup(TP->Buffer);
} else {
Result = NULL;
}
free(TP);
return Result;
*/
}
static char* ExtractWordFromIE(HWND WND, POINT Pt, int *BeginPos)
{
return ExtractFromEverything(WND, Pt, BeginPos);
}
typedef struct TConsoleParams {
HWND WND;
POINT Pt;
RECT ClientRect;
char Buffer[256];
} TConsoleParams;
static int GetWordFromConsolePack(TConsoleParams *params)
{
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hStdOut != INVALID_HANDLE_VALUE) {
CONSOLE_SCREEN_BUFFER_INFO csbi;
if (GetConsoleScreenBufferInfo(hStdOut, &csbi)) {
COORD CurPos;
CurPos.X = csbi.srWindow.Left + params->Pt.x * (csbi.srWindow.Right - csbi.srWindow.Left + 1) / params->ClientRect.right;
CurPos.Y = csbi.srWindow.Top + params->Pt.y * (csbi.srWindow.Bottom - csbi.srWindow.Top + 1) / params->ClientRect.bottom;
if ((CurPos.X >= 0) && (CurPos.X <= csbi.dwSize.X - 1) && (CurPos.Y >= 0) && (CurPos.Y <= csbi.dwSize.Y - 1)) {
int BegPos;
BegPos = CurPos.X;
CurPos.X = 0;
char *Buf = GlobalAlloc(GMEM_FIXED, csbi.dwSize.X + 1);
if (Buf) {
DWORD ActualRead;
if ((ReadConsoleOutputCharacter(hStdOut, Buf, csbi.dwSize.X, CurPos, &ActualRead)) && (ActualRead == csbi.dwSize.X)) {
OemToCharBuff(Buf, Buf, csbi.dwSize.X);
int WordLen;
if (csbi.dwSize.X > 255)
WordLen = 255;
else
WordLen = csbi.dwSize.X;
strncpy(params->Buffer, Buf, WordLen);
GlobalFree(Buf);
return WordLen;
}
}
}
}
}
return 0;
}
static void GetWordFromConsolePackEnd() {}
static BOOL RemoteExecute(HANDLE hProcess, void *RemoteThread, DWORD RemoteSize, void *Data, int DataSize, DWORD *dwReturn)
{
void *pRemoteThread = VirtualAllocEx(hProcess, NULL, RemoteSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (!pRemoteThread)
return FALSE;
if (!WriteProcessMemory(hProcess, pRemoteThread, RemoteThread, RemoteSize, 0)) {
VirtualFreeEx(hProcess, pRemoteThread, RemoteSize, MEM_RELEASE);
return FALSE;
}
void *pData = VirtualAllocEx(hProcess, NULL, DataSize, MEM_COMMIT, PAGE_READWRITE);
if (!pData) {
VirtualFreeEx(hProcess, pRemoteThread, RemoteSize, MEM_RELEASE);
return FALSE;
}
if (!WriteProcessMemory(hProcess, pData, Data, DataSize, 0)) {
VirtualFreeEx(hProcess, pRemoteThread, RemoteSize, MEM_RELEASE);
VirtualFreeEx(hProcess, pData, DataSize, MEM_RELEASE);
return FALSE;
}
// Bug: I don't know why the next line will fail in Windows XP, so get word from cmd.exe can't work presently.
HANDLE hThread = CreateRemoteThread(hProcess, 0, 0, (LPTHREAD_START_ROUTINE)pRemoteThread, pData, 0, 0);
WaitForSingleObject(hThread, INFINITE);
GetExitCodeThread(hThread, dwReturn);
ReadProcessMemory(hProcess, pData, Data, DataSize, 0);
VirtualFreeEx(hProcess, pRemoteThread, RemoteSize, MEM_RELEASE);
VirtualFreeEx(hProcess, pData, DataSize, MEM_RELEASE);
if (hThread) {
CloseHandle(hThread);
return TRUE;
} else {
return FALSE;
}
}
static char* GetWordFromConsole(HWND WND, POINT Pt, int *BeginPos)
{
TConsoleParams *TP;
TP = malloc(sizeof(TConsoleParams));
TP->WND = WND;
TP->Pt = Pt;
ScreenToClient(WND, &(TP->Pt));
GetClientRect(WND, &(TP->ClientRect));
DWORD pid;
GetWindowThreadProcessId(GetParent(WND), &pid);
DWORD MaxWordSize;
if (pid != GetCurrentProcessId()) {
// The next line will fail in Win2k, but OK in Windows XP.
HANDLE ph = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, FALSE, pid);
if (ph) {
if (!RemoteExecute(ph, GetWordFromConsolePack, (DWORD)GetWordFromConsolePackEnd - (DWORD)GetWordFromConsolePack, TP, sizeof(TConsoleParams), &MaxWordSize))
MaxWordSize = 0;
CloseHandle(ph);
}
} else {
MaxWordSize = GetWordFromConsolePack(TP);
}
char *Result;
if (MaxWordSize > 0) {
Result = strdup(TP->Buffer);
} else {
Result = NULL;
}
free(TP);
return Result;
}
char* TryGetWordFromAnyWindow(TKnownWndClass WndType, HWND WND, POINT Pt, int *BeginPos)
{
typedef char* (*GetWordFunction_t)(HWND, POINT, int*);
const GetWordFunction_t GetWordFunction[]= {
ExtractFromEverything,
ExtractWordFromRichEditPos,
ExtractWordFromEditPos,
ExtractWordFromEditPos,
ExtractWordFromIE,
GetWordFromConsole,
};
return GetWordFunction[WndType](WND, Pt, BeginPos);
}
=============================
GetWord.h
=============================
#ifndef _GetWord_H_
#define _GetWord_H_
#include <windows.h>
typedef enum TKnownWndClass {
kwcUnknown,
kwcRichEdit,
kwcMultiLineEdit,
kwcSingleLineEdit,
kwcInternetExplorer_Server,
kwcConsole,
} TKnownWndClass;
TKnownWndClass GetWindowType(HWND WND, const char* WNDClass);
char* TryGetWordFromAnyWindow(TKnownWndClass WndType, HWND WND, POINT Pt, int *BeginPos);
#endif
=============================
HookImportFunction.c
=============================
#include "HookImportFunction.h"
#include<tlhelp32.h>
// These code come from: http://dev.csdn.net/article/2/2786.shtm
// I fixed a bug in it and improved it to hook all the modules of a program.
#define MakePtr(cast, ptr, AddValue) (cast)((DWORD)(ptr)+(DWORD)(AddValue))
static PIMAGE_IMPORT_DESCRIPTOR GetNamedImportDescriptor(HMODULE hModule, LPCSTR szImportModule)
{
if ((szImportModule == NULL) || (hModule == NULL))
return NULL;
PIMAGE_DOS_HEADER pDOSHeader = (PIMAGE_DOS_HEADER) hModule;
if (IsBadReadPtr(pDOSHeader, sizeof(IMAGE_DOS_HEADER)) || (pDOSHeader->e_magic != IMAGE_DOS_SIGNATURE)) {
return NULL;
}
PIMAGE_NT_HEADERS pNTHeader = MakePtr(PIMAGE_NT_HEADERS, pDOSHeader, pDOSHeader->e_lfanew);
if (IsBadReadPtr(pNTHeader, sizeof(IMAGE_NT_HEADERS)) || (pNTHeader->Signature != IMAGE_NT_SIGNATURE))
return NULL;
if (pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress == 0)
return NULL;
PIMAGE_IMPORT_DESCRIPTOR pImportDesc = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, pDOSHeader, pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
while (pImportDesc->Name) {
PSTR szCurrMod = MakePtr(PSTR, pDOSHeader, pImportDesc->Name);
if (stricmp(szCurrMod, szImportModule) == 0)
break;
pImportDesc++;
}
if (pImportDesc->Name == (DWORD)0)
return NULL;
return pImportDesc;
}
static BOOL IsNT()
{
OSVERSIONINFO stOSVI;
memset(&stOSVI, 0, sizeof(OSVERSIONINFO));
stOSVI.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
BOOL bRet = GetVersionEx(&stOSVI);
if (FALSE == bRet) return FALSE;
return (VER_PLATFORM_WIN32_NT == stOSVI.dwPlatformId);
}
static BOOL HookImportFunction(HMODULE hModule, LPCSTR szImportModule, LPCSTR szFunc, PROC paHookFuncs, PROC* paOrigFuncs)
{
if (!IsNT() && ((DWORD)hModule >= 0x80000000))
return FALSE;
PIMAGE_IMPORT_DESCRIPTOR pImportDesc = GetNamedImportDescriptor(hModule, szImportModule);
if (pImportDesc == NULL)
return FALSE;
PIMAGE_THUNK_DATA pOrigThunk = MakePtr(PIMAGE_THUNK_DATA, hModule, pImportDesc->OriginalFirstThunk);
PIMAGE_THUNK_DATA pRealThunk = MakePtr(PIMAGE_THUNK_DATA, hModule, pImportDesc->FirstThunk);
while (pOrigThunk->u1.Function) {
if (IMAGE_ORDINAL_FLAG != (pOrigThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG)) {
PIMAGE_IMPORT_BY_NAME pByName = MakePtr(PIMAGE_IMPORT_BY_NAME, hModule, pOrigThunk->u1.AddressOfData);
// When hook EditPlus, read pByName->Name[0] will case this dll terminate, so call IsBadReadPtr() here.
if (IsBadReadPtr(pByName, sizeof(IMAGE_IMPORT_BY_NAME))) {
pOrigThunk++;
pRealThunk++;
continue;
}
if ('\0' == pByName->Name[0]) {
pOrigThunk++;
pRealThunk++;
continue;
}
BOOL bDoHook = FALSE;
if ((szFunc[0] == pByName->Name[0]) && (strcmpi(szFunc, (char*)pByName->Name) == 0)) {
if (paHookFuncs)
bDoHook = TRUE;
}
if (bDoHook) {
MEMORY_BASIC_INFORMATION mbi_thunk;
VirtualQuery(pRealThunk, &mbi_thunk, sizeof(MEMORY_BASIC_INFORMATION));
VirtualProtect(mbi_thunk.BaseAddress, mbi_thunk.RegionSize, PAGE_READWRITE, &mbi_thunk.Protect);
if (paOrigFuncs)
*paOrigFuncs = (PROC)pRealThunk->u1.Function;
pRealThunk->u1.Function = (DWORD)paHookFuncs;
DWORD dwOldProtect;
VirtualProtect(mbi_thunk.BaseAddress, mbi_thunk.RegionSize, mbi_thunk.Protect, &dwOldProtect);
return TRUE;
}
}
pOrigThunk++;
pRealThunk++;
}
return FALSE;
}
BOOL HookAPI(LPCSTR szImportModule, LPCSTR szFunc, PROC paHookFuncs, PROC* paOrigFuncs)
{
if ((szImportModule == NULL) || (szFunc == NULL)) {
return FALSE;
}
HANDLE hSnapshot;
hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,0);
MODULEENTRY32 me = {sizeof(MODULEENTRY32)};
BOOL bOk = Module32First(hSnapshot,&me);
while (bOk) {
HookImportFunction(me.hModule, szImportModule, szFunc, paHookFuncs, paOrigFuncs);
bOk = Module32Next(hSnapshot,&me);
}
return TRUE;
}
=============================
HookImportFunction.h
=============================
#ifndef _HookImportFunction_H_
#define _HookImportFunction_H_
#include <windows.h>
BOOL HookAPI(LPCSTR szImportModule, LPCSTR szFunc, PROC paHookFuncs, PROC* paOrigFuncs);
#endif
=============================
mouseover.c
=============================
/*
* This file part of StarDict - A international dictionary for GNOME.
* http://stardict.sourceforge.net
*
* Copyright (C) 2006 Hu Zheng
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "../stardict.h"
#include "../conf.h"
#include <glib/gi18n.h>
#include "mouseover.h"
#include "ThTypes.h"
// StarDict's Mouseover feature get the example delphi source code from Mueller Electronic Dicionary.
// Homepage: http://vertal1.narod.ru/mueldic.html E-mail: svv_soft@mail.ru
const int WM_MY_SHOW_TRANSLATION = WM_USER + 300;
void Mouseover::NeedSpyDll()
{
if (fSpyDLL == 0) {
fSpyDLL = LoadLibrary((gStarDictDataDir+G_DIR_SEPARATOR+"TextOutSpy.dll").c_str());
if (fSpyDLL==0) {
fSpyDLL = (HINSTANCE)-1;
} else {
ActivateSpy_func = (ActivateSpy_func_t)GetProcAddress(fSpyDLL, "ActivateTextOutSpying");
}
}
}
HWND Mouseover::Create_hiddenwin()
{
WNDCLASSEX wcex;
TCHAR wname[32];
strcpy(wname, "StarDictMouseover");
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = 0;
wcex.lpfnWndProc = (WNDPROC)mouseover_mainmsg_handler;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = stardictexe_hInstance;
wcex.hIcon = NULL;
wcex.hCursor = NULL,
wcex.hbrBackground = NULL;
wcex.lpszMenuName = NULL;
wcex.lpszClassName = wname;
wcex.hIconSm = NULL;
RegisterClassEx(&wcex);
// Create the window
return (CreateWindow(wname, "", 0, 0, 0, 0, 0, GetDesktopWindow(), NULL, stardictexe_hInstance, 0));
}
void Mouseover::ShowTranslation()
{
if (bIsPureEnglish(GlobalData->CurMod.MatchedWord)) {
gpAppFrame->SmartLookupToFloat(GlobalData->CurMod.MatchedWord, GlobalData->CurMod.BeginPos, true);
} else {
char *str1 = g_locale_to_utf8(GlobalData->CurMod.MatchedWord, GlobalData->CurMod.BeginPos, NULL, NULL, NULL);
char *str2 = g_locale_to_utf8(GlobalData->CurMod.MatchedWord + GlobalData->CurMod.BeginPos, GlobalData->CurMod.WordLen - GlobalData->CurMod.BeginPos, NULL, NULL, NULL);
GlobalData->CurMod.BeginPos = strlen(str1);
char *str = g_strdup_printf("%s%s", str1, str2);
g_free(str1);
g_free(str2);
gpAppFrame->SmartLookupToFloat(str, GlobalData->CurMod.BeginPos, true);
g_free(str);
}
}
LRESULT CALLBACK Mouseover::mouseover_mainmsg_handler(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch (msg) {
case WM_MY_SHOW_TRANSLATION:
ShowTranslation();
break;
default:
/*nothing*/;
}
return DefWindowProc(hwnd, msg, wparam, lparam);
}
Mouseover::Mouseover()
{
fSpyDLL = 0;
ActivateSpy_func = NULL;
}
void Mouseover::Init()
{
ThTypes_Init();
ZeroMemory(GlobalData, sizeof(TGlobalDLLData));
strcpy(GlobalData->LibName, (gStarDictDataDir+G_DIR_SEPARATOR+"TextOutHook.dll").c_str());
GlobalData->ServerWND = Create_hiddenwin();
}
void Mouseover::End()
{
if ((fSpyDLL!=0)&&(fSpyDLL!=(HINSTANCE)-1)) {
stop();
FreeLibrary(fSpyDLL);
}
DestroyWindow(GlobalData->ServerWND);
Thtypes_End();
}
void Mouseover::start()
{
NeedSpyDll();
if (ActivateSpy_func)
ActivateSpy_func(true);
}
void Mouseover::stop()
{
if (ActivateSpy_func)
ActivateSpy_func(false);
}
=============================
mouseover.h
=============================
#ifndef __SD_MOUSEOVER_H__
#define __SD_MOUSEOVER_H__
#include <windows.h>
class Mouseover
{
private:
typedef void (*ActivateSpy_func_t)(bool);
ActivateSpy_func_t ActivateSpy_func;
HINSTANCE fSpyDLL;
void NeedSpyDll();
HWND Create_hiddenwin();
static void ShowTranslation();
static LRESULT CALLBACK mouseover_mainmsg_handler(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
public:
Mouseover();
void Init();
void End();
void start();
void stop();
};
#endif
=============================
stardict.cpp
=============================
bool AppCore::SmartLookupToFloat(const gchar* sWord, int BeginPos, bool bShowIfNotFound)
{
if (sWord==NULL || sWord[0]=='\0')
return true;
char *SearchWord = g_strdup(sWord);
char *P1 = SearchWord + BeginPos;
P1 = g_utf8_next_char(P1);
while (*P1 && !g_unichar_isspace(g_utf8_get_char(P1)))
P1 = g_utf8_next_char(P1);
*P1='\0';
P1 = SearchWord + BeginPos;
if (BeginPos) {
if (g_unichar_isspace(g_utf8_get_char(P1)))
P1 = g_utf8_prev_char(P1);
while (P1>SearchWord && !g_unichar_isspace(g_utf8_get_char(g_utf8_prev_char(P1))))
P1 = g_utf8_prev_char(P1);
}
const gchar **ppWord = (const gchar **)g_malloc(sizeof(gchar *) * oLibs.ndicts());
gchar **ppWordData = (gchar **)g_malloc(sizeof(gchar *) * oLibs.ndicts());
int SearchTimes = 2;
while (SearchTimes) {
glong iIndex;
bool bFound = false;
for (int iLib=0;iLibSearchWord && isascii(*(P3-1)) && g_ascii_isupper(*(P3-1)))
P3--;
} else if (g_ascii_islower(*P2)){
P2++;
while (*P2 && g_ascii_islower(*P2))
P2++;
}
if (*P2) {
*P2='\0';
} else {
if (P3==P1)
break;
}
P1=P3;
} else {
while (P3>SearchWord && isascii(*(P3-1)) && g_ascii_isupper(*(P3-1)))
P3--;
if (P3==P1)
break;
}
} else if (g_ascii_islower(*P2)) {
char *P3 = SearchWord + BeginPos;
while (P3>SearchWord && isascii(*(P3-1)) && g_ascii_islower(*(P3-1)))
P3--;
if (P3>SearchWord && isascii(*(P3-1)) && g_ascii_isupper(*(P3-1)))
P3--;
P2++;
while (*P2 && g_ascii_islower(*P2))
P2++;
if (*P2) {
*P2='\0';
} else {
if (P3==P1)
break;
}
P1=P3;
} else {
break;
}
} else {
if (P1==SearchWord + BeginPos) {
char *EndPointer=P1+strlen(P1);
EndPointer = g_utf8_prev_char(EndPointer);
if (EndPointer!=P1) {
*EndPointer='\0';
SearchTimes = 2;
}
else {
break;
}
} else {
P1 = SearchWord + BeginPos;
SearchTimes = 2;
}
}
}
g_free(ppWord);
g_free(ppWordData);
// not found
if (bShowIfNotFound) {
ShowNotFoundToFloatWin(P1,_(""), false);
oTopWin.InsertHisList(P1); //really need?
}
g_free(SearchWord);
return false;
}
=============================
[ Last edited by zzz19760225 on 2017-7-20 at 23:37 ]
|
1<词>，2[句]，3/段\，4{节}，5(章)。 |
|
|
2016-6-26 19:10 |
|
|
