[svnbook commit] r1626 - trunk/src/zh/book

rocksun svnbook-dev at red-bean.com
Fri Aug 19 23:14:26 CDT 2005

Author: rocksun
Date: Fri Aug 19 23:14:25 2005
New Revision: 1626

* zh/book/ch08.xml: before using APIs 
* zh/book/glossary.xml: add some new words

Modified: trunk/src/zh/book/ch08.xml
--- trunk/src/zh/book/ch08.xml	(original)
+++ trunk/src/zh/book/ch08.xml	Fri Aug 19 23:14:25 2005
@@ -1,27 +1,12 @@
-<chapter id="svn-ch-8">
-  <title>Developer Information</title>
+<chapter id="svn-ch-8">
+  <title>开发者信息</title>
-    <para>Subversion is an open-source software project developed
-      under an Apache-style software license.  The project is
-      financially backed by CollabNet, Inc., a California-based
-      software development company.  The community that has formed
-      around the development of Subversion always welcomes new members
-      who can donate their time and attention to the project.
-      Volunteers are encouraged to assist in any way they can, whether
-      that means finding and diagnosing bugs, refining existing source
-      code, or fleshing out whole new features.</para>
+    <para>Subversion是一个开源的软件项目,使用Apache样式的软件许可证。这个项目由加利福尼亚为基地的CollabNet, Inc.软件开发公司资助。这个关于Subversion开发的社区一直欢迎新成员贡献自己的时间和注意力。鼓励志愿者做他们想做的任何帮助,不管是发现和诊断bug,精炼存在的代码还是补充新的特性。
+   </para>
-    <para>This chapter is for those who wish to assist in the
-      continued evolution of Subversion by actually getting their
-      hands dirty with the source code.  We will cover some of the
-      software's more intimate details, the kind of technical
-      nitty-gritty that those developing Subversion itself—or
-      writing entirely new tools based on the Subversion
-      libraries—should be aware of.  If you don't foresee
-      yourself participating with the software at such a level, feel
-      free to skip this chapter with confidence that your experience
-      as a Subversion user will not be affected.</para>
+    <para>本章是为那些希望亲自参与源代码来帮助Subversion进化的人们准备的,我们会覆盖许多软件内在的细节,关系到开发Subversion本质的技术—或者是使用Subversion库编写全新的工具—必须意识到这一点。如果你没有预见到你会以这种层次参与到软件中来,也可以随意掠过这一张你作为Subversion用户的经验不会受到影响。
+   </para>
@@ -29,275 +14,152 @@
   <!-- *** SECTION 1:  LAYERED LIBRARY DESIGN                          *** -->
   <!-- ******************************************************************* -->
   <sect1 id="svn-ch-8-sect-1">
-    <title>Layered Library Design</title>
+    <title>分层的库设计</title>
-    <para>Subversion has a modular design, implemented as a collection
-      of C libraries.  Each library has a well-defined purpose and
-      interface, and most modules are said to exist in one of three
-      main layers—the Repository Layer, the Repository Access
-      (RA) Layer, or the Client Layer.  We will examine these layers
-      shortly, but first, see our brief inventory of Subversion's
-      libraries in <xref linkend="svn-ch-8-table-1"/>.  For the sake
-      of consistency, we will refer to the libraries by their
-      extensionless Unix library names (e.g.: libsvn_fs, libsvn_wc,
-      mod_dav_svn).</para>
+    <para>Subversion有一个模块化的设计,通过一套C库实现。每一个库都有一套定义良好的目的和接口,每一个模块都属于三层中某一层—版本库层,版本库访问(RA)层或是客户端层。我们会立刻考察这些层,但是首先让我们看一下<xref linkend="svn-ch-8-table-1"/>中的Subversion库的摘要目录,为了一致性,我们通过他们的Unix库名称(例如libsvn_fs、libsvn_wc和mod_dav_svn)来引用它们。</para>
     <table id="svn-ch-8-table-1">
       <title>A Brief Inventory of the Subversion Libraries</title>
       <tgroup cols="2">
-            <entry>Library</entry>
-            <entry>Description</entry>
+            <entry>库</entry>
+            <entry>描述</entry>
-            <entry>Primary interface for client programs</entry>
+            <entry>客户端程序的主要接口</entry>
-            <entry>Tree and text differencing routines</entry>
+            <entry>目录树和文本区别程序</entry>
-            <entry>The Subversion filesystem library</entry>
+            <entry>Subversion文件系统库</entry>
-            <entry>The Berkeley DB filesystem back-end</entry>
+            <entry>Berkeley DB文件系统后端</entry>
-            <entry>The native filesystem (FSFS) back-end</entry>
+            <entry>本地文件系统(FSFS)后端</entry>
-            <entry>Repository Access commons and module loader</entry>
+            <entry>版本库访问通用组件和模块装载器</entry>
-            <entry>The WebDAV Repository Access module</entry>
+            <entry>WebDAV版本库访问模块</entry>
-            <entry>The local Repository Access module</entry>
+            <entry>本地版本库访问模块</entry>
-            <entry>A custom protocol Repository Access module</entry>
+            <entry>一个自定义版本库访问模块</entry>
-            <entry>Repository interface</entry>
+            <entry>版本库接口</entry>
-            <entry>Miscellaneous helpful subroutines</entry>
+            <entry>各种有用的子程序</entry>
-            <entry>The working copy management library</entry>
+            <entry>工作拷贝管理库</entry>
-            <entry>Apache authorization module for Subversion
-            repositories access via WebDAV</entry>
+            <entry>使用WebDAV访问Subversion版本库的Apache授权模块</entry>
-            <entry>Apache module for mapping WebDAV operations to
-            Subversion ones</entry>
+            <entry>影射WebDAV操作为Subversion操作的Apache模块</entry>
-    <para>The fact that the word <quote>miscellaneous</quote> only
-      appears once in <xref linkend="svn-ch-8-table-1"/> is a good
-      sign.  The Subversion development team is serious about making
-      sure that functionality lives in the right layer and libraries.
-      Perhaps the greatest advantage of the modular design is its lack
-      of complexity from a developer's point of view.  As a developer,
-      you can quickly formulate that kind of <quote>big
-      picture</quote> that allows you to pinpoint the location of
-      certain pieces of functionality with relative ease.</para>
-    <para>Another benefit of modularity is the ability to replace a
-      given module with a whole new library that implements the same
-      API without affecting the rest of the code base.  In some sense,
-      this happens within Subversion already.  The libsvn_ra_dav,
-      libsvn_ra_local, and libsvn_ra_svn all implement the same
-      interface.  And all three communicate with the Repository
-      Layer—libsvn_ra_dav and libsvn_ra_svn do so across a
-      network, and libsvn_ra_local connects to it directly.</para>
-    <para>The client itself also highlights modularity in the
-      Subversion design.  While Subversion currently comes with only a
-      command-line client program, there are already a few other
-      programs being developed by third parties to act as GUIs for
-      Subversion.  Again, these GUIs use the same APIs that the stock
-      command-line client does.  Subversion's libsvn_client library is
-      the one-stop shop for most of the functionality necessary for
-      designing a working Subversion client (see <xref
-      linkend="svn-ch-8-sect-1.3"/>).</para>
+    <para>单词<quote>各种</quote>只在列表<xref linkend="svn-ch-8-table-1"/>出现了一次是一个好的迹象。Subversion开发团队十分看重功能所在的层库,或许模块化设计最大的好处就是从开发者角度看减少了复杂性。作为一个开发者,你很快可以明确的说明那副<quote>大图片</quote>,允许你容易的找出某一块功能所在的位置。</para>
+    <para>模块化的另一个好处是我们有能力用实现同样API的新模块替换整个给定的模块,而又不会影响代码基础。在一些方面,Subversion已经这样做了。libsvn_ra_dav、libsvn_ra_local和libsvn_ra_svn all都实现了同样的接口,三个都与版本库层通讯—libsvn_ra_dav和libsvn_ra_svn通过网络,而libsvn_ra_local则是直接连接。
+   </para>
+    <para>在Subversion的设计中,客户端本身也集萃了许多模块。虽然Subversion目前只是伴随了一个命令行的客户端,但也已经有一些第三方设计的GUI程序,这些GUI程序使用命令行客户端同样的API。Subversion的libsvn_client库集合了作为Subversion客户端的几乎所有必要的功能(见<xref
+      linkend="svn-ch-8-sect-1.3"/>)。</para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-8-sect-1.1">
-      <title>Repository Layer</title>
+      <title>版本库层</title>
+      <para>当提到Subversion的版本库层,我们通常会讨论两个库—版本库库和文件系统库。这两个库为多修订版本中版本控制的数据提供了存储和报告机制,这一层是通过版本库访问层连接到客户端层的,同样,从Subversion用户的角度,这件事是<quote>在绳子的另一端。</quote></para>
+      <para>Subversion文件系统是通过libsvn_fs的API访问的,这不是一个可以安装到操作系统(例如Linux ext2或NTFS)的内核级文件系统,而是一个虚拟文件系统。不是用真实的文件和目录(也就是你用shell程序可以导航的那种)保存<quote>文件</quote>和<quote>目录</quote>,而是从两种抽象后端方式中选择一种使用—一个是Berkeley DB数据库环境或者是一个普通文件表示。(为了了解更多关于版本库后端的信息,请看<xref
+        linkend="svn-ch-5-sect-1.3"/>)。然而,社区也非常有兴趣考虑使Subversion具备使用其它后端数据库系统的能力,或许通过一个类似开放式数据库连接(JDBC)的机制。</para>
+      <para>libsvn_fs支持的文件系统API包含了所有其他文件系统的功能:你可以创建和删除文件和目录、拷贝和移动、修改文件内容等等。它也包含了一些不太常用的特性,如对任意文件和目录添加、修改和删除元数据(<quote>properties</quote>)的能力。此外,Subversion文件系统是一个版本化的文件系统,意味着你修改你的目录树时,Subversion会记住修改以前的样子。等等,所有的回到开始版本化的时间是在添加到文件系统的时候(且刚刚超过***)。</para>
-      <para>When referring to Subversion's Repository Layer, we're
-        generally talking about two libraries—the repository
-        library, and the filesystem library.  These libraries provide
-        the storage and reporting mechanisms for the various revisions
-        of your version-controlled data.  This layer is connected to
-        the Client Layer via the Repository Access Layer, and is, from
-        the perspective of the Subversion user, the stuff at the
-        <quote>other end of the line.</quote></para>
-      <para>The Subversion Filesystem is accessed via the libsvn_fs
-        API, and is not a kernel-level filesystem that one would
-        install in an operating system (like the Linux ext2 or NTFS),
-        but a virtual filesystem.  Rather than storing
-        <quote>files</quote> and <quote>directories</quote> as real
-        files and directories (as in, the kind you can navigate
-        through using your favorite shell program), it uses one of two
-        available abstract storage backends—either a Berkeley DB
-        database environment, or a flat-file representation.  (To
-        learn more about the two repository back-ends, see <xref
-        linkend="svn-ch-5-sect-1.3"/>.)  However, there has been
-        considerable interest by the development community in giving
-        future releases of Subversion the ability to use other
-        back-end database systems, perhaps through a mechanism such as
-        Open Database Connectivity (ODBC).</para>
-      <para>The filesystem API exported by libsvn_fs contains the
-        kinds of functionality you would expect from any other
-        filesystem API: you can create and remove files and
-        directories, copy and move them around, modify file contents,
-        and so on.  It also has features that are not quite as common,
-        such as the ability to add, modify, and remove metadata
-        (<quote>properties</quote>) on each file or directory.
-        Furthermore, the Subversion Filesystem is a versioning
-        filesystem, which means that as you make changes to your
-        directory tree, Subversion remembers what your tree looked
-        like before those changes.  And before the previous changes.
-        And the previous ones.  And so on, all the way back through
-        versioning time to (and just beyond) the moment you first
-        started adding things to the filesystem.</para>
-      <para>All the modifications you make to your tree are done
-        within the context of a Subversion transaction.  The following
-        is a simplified general routine for modifying your
-        filesystem:</para>
+      <para>所有你对目录树的修改包含在Subversion事务的上下文中,下面描述了修改文件系统的例程:
+      </para>
-          <para>Begin a Subversion transaction.</para>
+          <para>开始Subversion事务。</para>
-          <para>Make your changes (adds, deletes, property
-            modifications, etc.).</para>
+          <para>作出修改(添加、删除、属性修改等等。)。</para>
-          <para>Commit your transaction.</para>
+          <para>提交事务。</para>
-      <para>Once you have committed your transaction, your filesystem
-        modifications are permanently stored as historical artifacts.
-        Each of these cycles generates a single new revision of your
-        tree, and each revision is forever accessible as an immutable
-        snapshot of <quote>the way things were.</quote></para>
+      <para>一旦你提交了你的事务,你的文件系统修改就会永久的作为历史保存起来,每个这样的周期会产生一个新的树,所有的修订版本都是永远可以访问的一个不变的快照。</para>
-        <title>The Transaction Distraction</title>
+        <title>事务其它</title>
-        <para>The notion of a Subversion transaction, especially given
-          its close proximity to the database code in libsvn_fs, can
-          become easily confused with the transaction support provided
-          by the underlying database itself.  Both types of
-          transaction exist to provide atomicity and isolation.  In
-          other words, transactions give you the ability to perform a
-          set of actions in an <quote>all or nothing</quote>
-          fashion—either all the actions in the set complete
-          with success, or they all get treated as if
-          <emphasis>none</emphasis> of them ever happened—and in
-          a way that does not interfere with other processes acting on
-          the data.</para>
-        <para>Database transactions generally encompass small
-          operations related specifically to the modification of data
-          in the database itself (such as changing the contents of a
-          table row).  Subversion transactions are larger in scope,
-          encompassing higher-level operations like making
-          modifications to a set of files and directories which are
-          intended to be stored as the next revision of the filesystem
-          tree.  If that isn't confusing enough, consider this:
-          Subversion uses a database transaction during the creation
-          of a Subversion transaction (so that if the creation of
-          Subversion transaction fails, the database will look as if
-          we had never attempted that creation in the first
-          place)!</para>
-        <para>Fortunately for users of the filesystem API, the
-          transaction support provided by the database system itself
-          is hidden almost entirely from view (as should be expected
-          from a properly modularized library scheme).  It is only
-          when you start digging into the implementation of the
-          filesystem itself that such things become visible (or
-          interesting).</para>
+        <para>Subversion的事务概念,特别是在libsvn_fs中的数据库附近的代码,很容易与低层提供支持的数据库事务混淆。两种类型事务都提供了原子和隔离操作,换句话说,事务给你能力可以用<quote>全部或者没有</quote>样式执行一系列的动作—所有的动作都完全成功,或者是所有的<emphasis>没有</emphasis>发生—而且不会干扰别人操作数据。
+       </para>
+        <para>数据库事务通常围绕着一些对数据库本身的数据修改相关的小操作(如修改表行的内容),Subversion是更大范围的事务,围绕着一些高一级的操作,如下一个修订版本文件系统的一组文件和目录的修改。如果这还不是很混乱,考虑这个:Subversion在创建Subversion事务(所以如果Subversion创建事务失败,数据库会看起来我们从来没有尝试创建)时会使用一个数据库事务!
+       </para>
+        <para>很幸运的是用户的文件系统API,数据库提供的事务支持本身几乎完全从外表隐藏(也是一个完全模块化的模式所应该的)。只有当你开始研究文件系统本身的实现时,这些事情才可见(或者是开始感兴趣)。
+       </para>
-      <para>Most of the functionality provided by the filesystem
-        interface comes as an action that occurs on a filesystem path.
-        That is, from outside of the filesystem, the primary mechanism
-        for describing and accessing the individual revisions of files
-        and directories comes through the use of path strings like
-        <filename>/foo/bar</filename>, just as if you were addressing
-        files and directories through your favorite shell program.
-        You add new files and directories by passing their paths-to-be
-        to the right API functions.  You query for information about
-        them by the same mechanism.</para>
-      <para>Unlike most filesystems, though, a path alone is not
-        enough information to identify a file or directory in
-        Subversion.  Think of a directory tree as a two-dimensional
-        system, where a node's siblings represent a sort of
-        left-and-right motion, and descending into subdirectories a
-        downward motion.  <xref linkend="svn-ch-8-dia-1"/> shows
-        a typical representation of a tree as exactly that.</para>
+      <para>大多数文件系统接口提供的功能作为一个动作发生在一个文件系统路径上,也就是,从文件系统的外部,描述和访问文件和目录独立版本的主要机制是经过如<filename>/foo/bar</filename>的路径,就像你在喜欢的shell程序中定位文件和目录。你通过传递它们的路径到相应的API功能来添加新的文件和目录,查询这些信息也是同样的机制。
+     </para>
+      <para>不像大多数文件系统,尽管,一个单独的路径不足以在Subversion定位一个文件或目录,可以把目录树看作一个二维的系统,一个节点的兄弟代表了一种从左到右的动作,并且递减到子目录是一个向下的动作,<xref linkend="svn-ch-8-dia-1"/>展示了一个典型的树的形式。
+     </para>
       <figure id="svn-ch-8-dia-1">
-        <title>Files and directories in two dimensions</title>
+        <title>二维的文件目录</title>
         <graphic fileref="images/ch08dia1.png"/>
-      <para>Of course, the Subversion filesystem has a nifty third
-        dimension that most filesystems do not have—Time!
+      <para>当然,Subversion文件系统有一个其它文件系统的第三维—时间!
-          <para>We understand that this may come as a shock to sci-fi
-            fans who have long been under the impression that Time was
-            actually the <emphasis>fourth</emphasis> dimension, and we
-            apologize for any emotional trauma induced by our
-            assertion of a different theory.</para>
+          <para>我们理解这一定会给科幻小说迷带来一个震撼,他们认为时间是<emphasis>第四</emphasis>维的,我们要为提出这样一个不同理论的断言而伤害了他们的作出道歉。
+         </para>
-        In the filesystem interface, nearly every function that has a
-        <parameter>path</parameter> argument also expects a
-        <parameter>root</parameter> argument.  This
-        <structname>svn_fs_root_t</structname> argument describes
-        either a revision or a Subversion transaction (which is
-        usually just a revision-to-be), and provides that
-        third-dimensional context needed to understand the difference
-        between <filename>/foo/bar</filename> in revision 32, and the
-        same path as it exists in revision 98.  <xref
-        linkend="svn-ch-8-dia-2"/> shows revision history as an
-        added dimension to the Subversion filesystem universe.</para>
+        在一个文件系统接口,几乎所有的功能都有个<parameter>路径</parameter>参数,也期望一个<parameter>root</parameter>参数。<structname>svn_fs_root_t</structname>参数不仅描述了一个修订版本或一个Subversion事务(通常正好是一个修订版本),而且提供了用来区分修订版本32的<filename>/foo/bar</filename>和修订版本98在同样路径的三维上下文环境。<xref
+        linkend="svn-ch-8-dia-2"/>展示了修订版本历史作为添加的纬度进入到Subversion文件系统领域。
+        </para>
       <figure id="svn-ch-8-dia-2">
-        <title>Versioning time—the third dimension!</title>
+        <title>版本时间—第三维!</title>
         <graphic fileref="images/ch08dia2.png"/>
@@ -306,52 +168,20 @@
            pleasures as cheap copies.  If "bubble-up" isn't covered
            twelve other times in the book, maybe give it a go here. -->
-      <para>As we mentioned earlier, the libsvn_fs API looks and feels
-        like any other filesystem, except that it has this wonderful
-        versioning capability.  It was designed to be usable by any
-        program interested in a versioning filesystem.  Not
-        coincidentally, Subversion itself is interested in that
-        functionality.  But while the filesystem API should be
-        sufficient for basic file and directory versioning support,
-        Subversion wants more—and that is where libsvn_repos
-        comes in.</para>
-      <para>The Subversion repository library (libsvn_repos) is
-        basically a wrapper library around the filesystem
-        functionality.  This library is responsible for creating the
-        repository layout, making sure that the underlying filesystem
-        is initialized, and so on.  Libsvn_repos also implements a set
-        of hooks—scripts that are executed by the repository
-        code when certain actions take place.  These scripts are
-        useful for notification, authorization, or whatever purposes
-        the repository administrator desires.  This type of
-        functionality, and other utilities provided by the repository
-        library, are not strictly related to implementing a versioning
-        filesystem, which is why it was placed into its own
-        library.</para>
+      <para>像之前我们提到的,libsvn_fs的API感觉像是其它文件系统,只是有一个美妙的版本化能力。它设计为为所有对版本化的文件系统有兴趣的程序使用,不是巧合,Subversion本身也对这个功能很有兴趣。但是虽然文件系统API一定必须对基本的文件和目录版本化提供足够的支持,Subversion需要的更多—这是libsvn_repos到来的地方。
+     </para>
+      <para>Subversion版本库库(libsvn_repos)是文件系统功能的一个基本包裹库,这个库负责创建版本库布局,确定底层的文件系统已经初始化等等。Libsvn_repos也实现了一组钩子—当特定动作发生时版本库执行的脚本。这些脚本用来通知,授权或者任何版本库管理员期望的目的。版本库库提供的这些功能和小工具与版本化的文件系统关系不大,所以放到了自己的库里。
+     </para>
-      <para>Developers who wish to use the libsvn_repos API will find
-        that it is not a complete wrapper around the filesystem
-        interface.  That is, only certain major events in the general
-        cycle of filesystem activity are wrapped by the repository
-        interface.  Some of these include the creation and commit of
-        Subversion transactions, and the modification of revision
-        properties.  These particular events are wrapped by the
-        repository layer because they have hooks associated with them.
-        In the future, other events may be wrapped by the repository
-        API.  All of the remaining filesystem interaction will
-        continue to occur directly via the libsvn_fs API, though.</para>
-      <para>For example, here is a code segment that illustrates the
-        use of both the repository and filesystem interfaces to create
-        a new revision of the filesystem in which a directory is
-        added.  Note that in this example (and all others throughout
-        this book), the <function>SVN_ERR</function> macro simply
-        checks for a non-successful error return from the function it
-        wraps, and returns that error if it exists.</para>
+      <para>希望使用libsvn_repos的API的开发者会发现它不是文件系统的一个完全包裹,只有文件系统常规周期中的主要事件使用版本库接口包裹,如包括Subversion事务的创建和提交,修订版本属性的修改。这些特别的事件使用版本库库包裹是因为它们有一些关联的钩子,在将来,别的事件也将会使用版本库API包裹。所有其它的文件系统交互会直接通过libsvn_fs的API发生。
+     </para>
+      <para>举个例子,这里是使用版本库和文件系统接口创建文件系统新修订版本的代码块,新版本包括添加一个新目录。注意这个例子(和其它本书中的代码),这个<function>SVN_ERR</function>宏只是简单的检查是否有一个非成功的错误从包裹的函数中返回,如果存在就会返回错误。
+     </para>
       <example id="svn-ch-8-sect-1.1-ex-1">
-        <title>Using the Repository Layer</title>
+        <title>使用版本库层</title>
 /* Create a new directory at the path NEW_DIRECTORY in the Subversion
@@ -430,91 +260,45 @@
-      <para>In the previous code segment, calls were made to both the
-        repository and filesystem interfaces.  We could just as easily
-        have committed the transaction using
-        <function>svn_fs_commit_txn</function>.  But the filesystem
-        API knows nothing about the repository library's hook
-        mechanism.  If you want your Subversion repository to
-        automatically perform some set of non-Subversion tasks every
-        time you commit a transaction (like, for example, sending an
-        email that describes all the changes made in that transaction
-        to your developer mailing list), you need to use the
-        libsvn_repos-wrapped version of that
-        function—<function>svn_repos_fs_commit_txn</function>.
-        This function will actually first run the
-        <literal>pre-commit</literal> hook script if one exists, then
-        commit the transaction, and finally will run a
-        <literal>post-commit</literal> hook script.  The hooks provide
-        a special kind of reporting mechanism that does not really
-        belong in the core filesystem library itself.  (For more
-        information regarding Subversion's repository hooks, see <xref
-        linkend="svn-ch-5-sect-2.1" />.)</para>
+      <para>在前面的代码片断中,同时调用了版本库和文件系统接口,我们可以正像这样简单的用<function>svn_fs_commit_txn</function>提交事务。但是文件系统的API对版本库库的钩子一无所知,如果你希望你的Subversion版本库在每次提交一个事务时自动执行一些非Subversion的任务(例如,给开发者邮件组发送一个描述事务修改的邮件),你需要使用libsvn_repos包裹的功能版本—<function>svn_repos_fs_commit_txn</function>。这个功能会实际上首先运行一个如果存在的<literal>pre-commit</literal>钩子脚本,然后提交事务,最后会运行一个<literal>post-commit</literal>钩子脚本。钩子提供了一种特别的报告机制,不是真的属于核心文件系统库本身。(关于Subversion版本库钩子的更多信息,见<xref
+        linkend="svn-ch-5-sect-2.1" />。)</para>
-      <para>The hook mechanism requirement is but one of the reasons
-        for the abstraction of a separate repository library from the
-        rest of the filesystem code.  The libsvn_repos API provides
-        several other important utilities to Subversion.  These
-        include the abilities to:</para>
+      <para>钩子机制需求是从文件系统代码的其它部分中抽象出单独的版本库库的一个原因,libsvn_repos的API提供了许多其他有用的工具,它们可以做到:
+     </para>
-          <para>create, open, destroy, and perform recovery steps on a
-            Subversion repository and the filesystem included in that
-            repository.</para>
+          <para>在Subversion版本库和版本库包括的文件系统的上创建、打开、销毁和执行恢复步骤。</para>
-          <para>describe the differences between two filesystem
-            trees.</para>
+          <para>描述两个文件系统树的区别。</para>
-          <para>query for the commit log messages
-            associated with all (or some) of the revisions in which a
-            set of files was modified in the filesystem.</para>
+          <para>关于所有(或者部分)修订版本中的文件系统中的一组文件的提交日志信息的查询</para>
-          <para>generate a human-readable <quote>dump</quote> of the
-            filesystem, a complete representation of the revisions in
-            the filesystem.</para>
+          <para>产生可读的文件系统<quote>导出</quote>,一个文件系统修订版本的完整展现。
+          </para>
-          <para>parse that dump format, loading the dumped revisions
-            into a different Subversion repository.</para>
+          <para>解析导出格式,加载导出的版本到一个不同的Subversion版本库。
+          </para>
-      <para>As Subversion continues to evolve, the repository library
-        will grow with the filesystem library to offer increased
-        functionality and configurable option support.</para>
+      <para>伴随着Subversion的发展,版本库库会随着文件系统提供更多的功能和配置选项而不断成长。
+      </para>
     <!-- ****************************************************************** -->
     <sect2 id="svn-ch-8-sect-1.2">
-      <title>Repository Access Layer</title>
+      <title>版本库访问层</title>
-      <para>If the Subversion Repository Layer is at <quote>the other
-        end of the line</quote>, the Repository Access Layer is the
-        line itself.  Charged with marshalling data between the client
-        libraries and the repository, this layer includes the
-        libsvn_ra module loader library, the RA modules themselves
-        (which currently includes libsvn_ra_dav, libsvn_ra_local, and
-        libsvn_ra_svn), and any additional libraries needed by one or
-        more of those RA modules, such as the mod_dav_svn Apache
-        module with which libsvn_ra_dav communicates or
-        libsvn_ra_svn's server, <command>svnserve</command>.</para>
-      <para>Since Subversion uses URLs to identify its repository
-        resources, the protocol portion of the URL schema (usually
-        <literal>file:</literal>, <literal>http:</literal>,
-        <literal>https:</literal>, or <literal>svn:</literal>) is used
-        to determine which RA module will handle the communications.
-        Each module registers a list of the protocols it knows how to
-        <quote>speak</quote> so that the RA loader can, at runtime,
-        determine which module to use for the task at hand.  You can
-        determine which RA modules are available to the Subversion
-        command-line client, and what protocols they claim to support,
-        by running <command>svn --version</command>:</para>
+      <para>如果说Subversion版本库层是在<quote>这条线的另一端</quote>,那版本库访问层就是这条线。负责在客户端库和版本库之间编码数据,这一层包括libsvn_ra模块加载模块,RA模块本身(现在包括了libsvn_ra_dav、libsvn_ra_local和libsvn_ra_svn),和所有一个或多个RA模块需要的附加库,例如与Apache模块mod_dav_svn通讯的libsvn_ra_dav或者是libsvn_ra_svn的服务器,<command>svnserve</command>。
+     </para>
+      <para>因为Subversion使用URL来识别版本库资源,URL模式的URL部分(通常是<literal>file:</literal>、<literal>http:</literal>、<literal>https:</literal>或<literal>svn:</literal>)用来监测那个RA模块用来处理通讯。每个模块注册一组它们知道如何<quote>说话</quote>的协议,所以RA加载器可以在运行中监测在手边的任务中使用那个模块。通过运行<command>svn --version</command>,你可以监测Subversion命令行客户端所支持的RA模块和他们声明支持的协议:</para>
 $ svn --version
@@ -537,96 +321,22 @@
       <sect3 id="svn-ch-8-sect-1.2.1">
-        <title>RA-DAV (Repository Access Using HTTP/DAV)</title>
+        <title>RA-DAV(使用HTTP/DAV版本库访问)</title>
-        <para>The libsvn_ra_dav library is designed for use by clients
-          that are being run on different machines than the servers
-          with which they communicating, specifically servers reached
-          using URLs that contain the <literal>http:</literal> or
-          <literal>https:</literal> protocol portions.  To understand
-          how this module works, we should first mention a couple of
-          other key components in this particular configuration of the
-          Repository Access Layer—the powerful Apache HTTP
-          Server, and the Neon HTTP/WebDAV client library.</para>
+        <para>libsvn_ra_dav库是给在不同机器使用<literal>http:</literal>或<literal>https:</literal>协议访问服务器的用户设计的,为了理解这个模块的工作,我们首先要知道这种版本库访问层中的特定配置的关键组成部分—强大的Apache HTTP服务器,和Neon HTTP/WebDAV客户端库。</para>
-        <para>Subversion's primary network server is the Apache HTTP
-          Server.  Apache is a time-tested, extensible open-source
-          server process that is ready for serious use.  It can
-          sustain a high network load and runs on many platforms.  The
-          Apache server supports a number of different standard
-          authentication protocols, and can be extended through the
-          use of modules to support many others.  It also supports
-          optimizations like network pipelining and caching.  By using
-          Apache as a server, Subversion gets all of these features
-          for free.  And since most firewalls already allow HTTP
-          traffic to pass through, sysadmins typically don't even have
-          to change their firewall configurations to allow Subversion
-          to work.</para>
+        <para>Subversion的主要网络服务器是Apache HTTP服务器,Apache是久经考验的用来认真使用的开源服务器,它可以支撑很大的网络压力并且可以运行在多种平台。Apache服务器支持多种认证协议,而且可以通过模块扩展使用其它协议。它也支持流水线和缓存之类的网络优化。通过将Apache作为服务器,Subversion轻易得到这些特性。而且因为许多防火墙已经允许HTTP通过,系统管理员通常不会改变防火墙设置来允许Subversion工作。</para>
-        <para>Subversion uses HTTP and WebDAV (with DeltaV) to
-          communicate with an Apache server.  You can read more about
-          this in the WebDAV section of this chapter, but in short,
-          WebDAV and DeltaV are extensions to the standard HTTP 1.1
-          protocol that enable sharing and versioning of files over
-          the web.  Apache 2.0 comes with mod_dav, an Apache module
-          that understands the DAV extensions to HTTP.  Subversion
-          itself supplies mod_dav_svn, though, which is another Apache
-          module that works in conjunction with (really, as a back-end
-          to) mod_dav to provide Subversion's specific implementations
-          of WebDAV and DeltaV.</para>
-        <para>When communicating with a repository over HTTP, the RA
-          loader library chooses libsvn_ra_dav as the proper access
-          module.  The Subversion client makes calls into the generic
-          RA interface, and libsvn_ra_dav maps those calls (which
-          embody rather large-scale Subversion actions) to a set of
-          HTTP/WebDAV requests.  Using the Neon library, libsvn_ra_dav
-          transmits those requests to the Apache server.  Apache
-          receives these requests (exactly as it does generic HTTP
-          requests that your web browser might make), notices that the
-          requests are directed at a URL that is configured as a DAV
-          location (using the <sgmltag>Location</sgmltag> directive in
-          <filename>httpd.conf</filename>), and hands the request off
-          to its own mod_dav module.  When properly configured,
-          mod_dav knows to use Subversion's mod_dav_svn for any
-          filesystem-related needs, as opposed to the generic
-          mod_dav_fs that comes with Apache.  So ultimately, the
-          client is communicating with mod_dav_svn, which binds
-          directly to the Subversion Repository Layer.</para>
+        <para>Subversion使用HTTP和WebDAV(和DeltaV)来与Apache服务器通讯,你可以在本章的WebDAV读到更多信息,但简而言之,WebDAV和DeltaV是标准HTTP 1.1协议的扩展,允许在web上对文件进行分享和版本操作。Apache 2.0版随着一个mod_dav,一个Apache理解HTTP DAV扩展的模块,Subversion本身提供了mod_dav_svn,尽管,这是另一个Apache模块,它与mod_dav结合(实际上mod_dav_svn是作为后端支持)使用来提供Subversion对WebDAV和DeltaV的实现。</para>
+        <para>当与版本库通过HTTP通讯时,RA加载器库选择libsvn_ra_dav作为正确的访问模块,Subversion客户端调用原始的RA接口,libsvn_ra_dav把这些调用(包含了大量Subversion操作)影射为一系列HTTP/WebDAV请求。使用Neon库,libsvn_ra_dav把这些请求传递到Apache服务器,Apache接受到这些请求(就像平时web服务器常做的那样处理原始的HTTP请求),注意到这些请求的URL已经配置为DAV的位置(使用<filename>httpd.conf</filename>的<sgmltag>Location</sgmltag>指示),并且会使用自己的mod_dav模块来处理。当正确的配置了mod_dav使之知道了使用mod_dav_svn来处理所有文件系统相关的要求,而不是使用默认的Apache自带的原始mod_dav_fs来处理。所以最终客户端是与mod_dav_svn通讯,直接与Subversion版本库层绑定。</para>
-        <para>That was a simplified description of the actual
-          exchanges taking place, though.  For example, the Subversion
-          repository might be protected by Apache's authorization
-          directives.  This could result in initial attempts to
-          communicate with the repository being rejected by Apache on
-          authorization grounds.  At this point, libsvn_ra_dav gets
-          back the notice from Apache that insufficient identification
-          was supplied, and calls back into the Client Layer to get
-          some updated authentication data.  If the data is supplied
-          correctly, and the user has the permissions that Apache
-          seeks, libsvn_ra_dav's next automatic attempt at performing
-          the original operation will be granted, and all will be
-          well.  If sufficient authentication information cannot be
-          supplied, the request will ultimately fail, and the client
-          will report the failure to the user.</para>
+        <para>有一个实际交换发生的简单描述,举个例子,Subversion版本库可以使用Apache的授权指示进行保护。这会导致初始的与版本库的通讯会被Apache的授权基础拒绝,在此刻,libsvn_ra_dav将提供不足鉴定的通知返回,并且回调客户端层来得到一些更新的认证数据。如果数据是正确提供,而且用户有访问的权限,会赋予libsvn_ra_dav的下一个对原操作的自动尝试权限,并且一切会很好。如果足够的认证信息不能提供,请求会最后失败,客户端也会报告给用户失败信息。</para>
         <!-- A diagram here? -->
-        <para>By using Neon and Apache, Subversion gets free
-          functionality in several other complex areas, too.  For
-          example, if Neon finds the OpenSSL libraries, it allows the
-          Subversion client to attempt to use SSL-encrypted
-          communications with the Apache server (whose own mod_ssl can
-          <quote>speak the language</quote>).  Also, both Neon itself
-          and Apache's mod_deflate can understand the
-          <quote>deflate</quote> algorithm (the same one used by the
-          PKZIP and gzip programs), so requests can be sent in smaller,
-          compressed chunks across the wire.  Other complex features
-          that Subversion hopes to support in the future include the
-          ability to automatically handle server-specified redirects
-          (for example, when a repository has been moved to a new
-          canonical URL) and taking advantage of HTTP
-          pipelining.</para>
+        <para>通过使用Neon和Apache,Subversion在许多其它领域的轻易得到复杂的功能。举个例子,如果Neon找到OpenSSL库,它允许Subversion客户端尝试与Apache服务器(它自己的mod_ssl<quote>可以说这个语言</quote>)使用SSL加密的通讯。Neon本身和Apache的mod_deflate都可以理解<quote>deflate</quote>算法(PKZIP和gzip共同使用的程序),所以请求可以压缩块方式传输。其它Subversion今后希望支持的复杂特性包括,自动处理服务器重定向(举个例子,当版本库转移到一个新的规范URL)和利用HTTP流水线的能力。
+       </para>
         <!-- Talk about another difference between CVS and Subversion.
              CVS users had to specify which auth mechanism to use
@@ -639,157 +349,64 @@
       <sect3 id="svn-ch-8-sect-1.2.2">
-        <title>RA-SVN (Custom Protocol Repository Access)</title>
+        <title>RA-SVN(自定义协议版本库访问)</title>
+        <para>作为标准HTTP/WebDAV协议的补充,Subversion也提供了一个使用自定义协议的RA实现,libsvn_ra_svn模块实现了自己的网络套接字连接,与一个独立服务器通讯—<filename>svnserve</filename>程序—在存放版本库的机器上。客户端可以使用<literal>svn://</literal>访问版本库。
+       </para>
-        <para>In addition to the standard HTTP/WebDAV protocol,
-          Subversion also provides an RA implementation that uses a
-          custom protocol.  The libsvn_ra_svn module implements
-          its own network socket connectivity, and communicates with a
-          stand-alone server—the <filename>svnserve</filename>
-          program—on the machine that hosts the
-          repository.  Clients access the repository using the
-          <literal>svn://</literal> schema.</para>
-        <para>This RA implementation lacks most of the advantages of
-          Apache mentioned in the previous section; however, it may be
-          appealing to some sysadmins nonetheless.  It is dramatically
-          easier to configure and run; setting up an
-          <filename>svnserve</filename> process is nearly
-          instantaneous.  It is also much smaller (in terms of lines
-          of code) than Apache, making it much easier to audit, for
-          security reasons or otherwise.  Furthermore, some sysadmins
-          may already have an SSH security infrastructure in place,
-          and want Subversion to use it.  Clients using ra_svn can
-          easily tunnel the protocol over SSH.</para>
+        <para>这个RA实现缺乏前面小节提到的Apache的大多数有点;然而虽然如此,系统管理员会非常有兴趣,因为这配置和运行异常的简单;设置一个<filename>svnserve</filename>几乎是立刻的,它与Apache相比也是非常的小(从代码长度这方面说),让它非常容易进行安全或其他方面原因的审核。此外,一些系统管理员或许已经有了一个SSH安全基础,希望Subversion使用它,客户端使用ra_svn可以容易的使用SSH封装这个协议。
+       </para>
       <sect3 id="svn-ch-8-sect-1.2.3">
-        <title>RA-Local (Direct Repository Access)</title>
+        <title>RA-Local(直接版本库访问)</title>
+        <para>并不是所有与Subversion版本库的通讯需要服务器进程和一个网络层。用户如果只是希望简单的访问本地磁盘的版本库,他们会使用<literal>file:</literal>的URL和libsvn_ra_local提供的功能。RA模块直接与版本库和文件系统库绑定,所以不需要网络通讯。
+       </para>
+        <para>Subversion需要服务器名称成为<literal>file:</literal>的URL的一部分,是<literal>localhost</literal>或者是为空。换句话说,你的URL必须看起来如<literal>file://localhost/path/to/repos</literal>或者<literal>file:///path/to/repos</literal>。
+       </para>
-        <para>Not all communications with a Subversion repository
-          require a powerhouse server process and a network layer.
-          For users who simply wish to access the repositories on
-          their local disk, they may do so using
-          <literal>file:</literal> URLs and the functionality provided
-          by libsvn_ra_local.  This RA module binds directly with the
-          repository and filesystem libraries, so no network
-          communication is required at all.</para>
-        <para>Subversion requires that the server name included as part
-          of the <literal>file:</literal> URL be either
-          <literal>localhost</literal> or empty, and that there be no
-          port specification.  In other words, your URLs should look
-          like either
-          <literal>file://localhost/path/to/repos</literal> or
-          <literal>file:///path/to/repos</literal>.</para>
-        <para>Also, be aware that Subversion's
-          <literal>file:</literal> URLs cannot be used in a regular
-          web browser the way typical <literal>file:</literal> URLs
-          can.  When you attempt to view a <literal>file:</literal>
-          URL in a regular web browser, it reads and displays the
-          contents of the file at that location by examining the
-          filesystem directly.  However, Subversion's resources exist
-          in a virtual filesystem (see <xref
-          linkend="svn-ch-8-sect-1.1" />), and your browser will not
-          understand how to read that filesystem.</para>
+        <para>也必须意识到Subversion的<literal>file:</literal> URL不能和在普通的web服务器中的<literal>file:</literal> URL一样工作。当你尝试在web服务器查看一个<literal>file:</literal>的URL,它会通过直接检测文件系统读取和显示那个位置的文件内容,但是Subversion的资源存在于虚拟文件系统(见<xref
+          linkend="svn-ch-8-sect-1.1" />)中,你的浏览器不会理解怎样读取这个文件系统。
+          </para>
       <sect3 id="svn-ch-8-sect-1.2.4">
-        <title>Your RA Library Here</title>
+        <title>你的RA库在这里</title>
-        <para>For those who wish to access a Subversion repository
-          using still another protocol, that is precisely why the
-          Repository Access Layer is modularized!  Developers can
-          simply write a new library that implements the RA interface
-          on one side and communicates with the repository on the
-          other.  Your new library can use existing network protocols,
-          or you can invent your own.  You could use inter-process
-          communication (IPC) calls, or—let's get crazy, shall
-          we?—you could even implement an email-based protocol.
-          Subversion supplies the APIs; you supply the creativity.</para>
+        <para>对那些一直希望使用另一个协议来访问Subversion版本库的人,正好是为什么版本库访问层是模块化的!开发者可以简单的编写一个新的库来在一侧实现RA接口并且与另一侧的版本库通讯。你的新库可以使用存在的网络协议,或者发明你自己的。你可以使用进程间的通讯调用,或者—让我们发狂,我们会吗?—你甚至可以实现一个电子邮件为基础的协议,Subversion提供了API;你提供创造性。
+       </para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-8-sect-1.3">
-      <title>Client Layer</title>
+      <title>客户端层</title>
-      <para>On the client side, the Subversion working copy is where
-        all the action takes place.  The bulk of functionality
-        implemented by the client-side libraries exists for the sole
-        purpose of managing working copies—directories full of
-        files and other subdirectories which serve as a sort of local,
-        editable <quote>reflection</quote> of one or more repository
-        locations—and propagating changes to and from the
-        Repository Access layer.</para>
-      <para>Subversion's working copy library, libsvn_wc, is directly
-        responsible for managing the data in the working copies.  To
-        accomplish this, the library stores administrative information
-        about each working copy directory within a special
-        subdirectory.  This subdirectory, named
-        <filename>.svn</filename>, is present in each working copy
-        directory and contains various other files and directories
-        which record state and provide a private workspace for
-        administrative action.  For those familiar with CVS, this
-        <filename>.svn</filename> subdirectory is similar in purpose
-        to the <filename>CVS</filename> administrative directories
-        found in CVS working copies.  For more information about the
-        <filename>.svn</filename> administrative area, see <xref
-        linkend="svn-ch-8-sect-3"/>in this chapter.</para>
-      <para>The Subversion client library, libsvn_client, has the
-        broadest responsibility; its job is to mingle the
-        functionality of the working copy library with that of the
-        Repository Access Layer, and then to provide the highest-level
-        API to any application that wishes to perform general revision
-        control actions.  For example, the function
-        <function>svn_client_checkout</function> takes a URL as an
-        argument.  It passes this URL to the RA layer and opens an
-        authenticated session with a particular repository.  It then
-        asks the repository for a certain tree, and sends this tree
-        into the working copy library, which then writes a full
-        working copy to disk (<filename>.svn</filename> directories
-        and all).</para>
-      <para>The client library is designed to be used by any
-        application.  While the Subversion source code includes a
-        standard command-line client, it should be very easy to write
-        any number of GUI clients on top of the client library.  New
-        GUIs (or any new client, really) for Subversion need not be
-        clunky wrappers around the included command-line
-        client—they have full access via the libsvn_client API
-        to same functionality, data, and callback mechanisms that the
-        command-line client uses.</para>
+      <para>在客户端这一面,Subversion工作拷贝是所有动作发生的地方。大多数客户端库实现的功能是为了管理工作拷贝的目的实现的—满是文件子目录的目录是一个或多个版本库位置的可编辑的本地<quote>影射</quote>—从版本库访问层来回传递修改。
+     </para>
+      <para>Subversion的工作拷贝库,libsvn_wc直接负责管理工作拷贝的数据,为了完成这一点,库会在工作拷贝的每个目录的特殊子目录中保存关于工作拷贝的管理性信息。这个子目录叫做<filename>.svn</filename>,出现在所有工作拷贝目录里,保存了各种记录了状态和用来在私有工作区工作的文件和目录。对那些熟悉CVS的用户,<filename>.svn</filename>子目录与<filename>CVS</filename>工作拷贝管理目录的作用类似,关于<filename>.svn</filename>管理区域的更多信息,见本章的<xref
+        linkend="svn-ch-8-sect-3"/>。
+        </para>
+      <para>Subversion客户端库libsvn_client具备最广泛的职责;它的工作是结合工作拷贝库和版本库访问苦的功能,然后为希望普通版本控制的应用提供最高级的API。举个例子,<function>svn_client_checkout</function>方法是用一个URL作为参数,传递这个URL到RA层然后在特定版本库打开一个会话。然后向版本库要求一个特定的目录树,然后把目录树发送给工作拷贝库,然后把完全的工作拷贝写到磁盘(<filename>.svn</filename>目录和一切)。</para>
+      <para>客户端库是为任何程序使用设计的,尽管Subversion的源代码包括了一个标准的命令行客户端,用客户端库编写GUI客户端也是很简单,Subversion新的GUI(或者任何新的客户端,真的)不需要紧密围绕包含的命令行客户端—他们对具有相同功能、数据和回调机制的libsvn_client的API有完全的访问权利。
+     </para>
-        <title>Binding Directly—A Word About Correctness</title>
+        <title>直接绑定—关于正确性</title>
+        <para>为什么GUI程序要直接访问libsvn_client而不以命令行客户端的包裹运行?除了效率以外,这也关系到潜在的正确性问题。一个命令行客户端程序(如Subversion提供的)如果绑定了客户端库,需要将反馈和请求数据字节从C翻译为刻度的输出,这种翻译时有损耗的,程序不能得到API所提供的所有信息,或者是得到紧凑的信息。
+       </para>
-        <para>Why should your GUI program bind directly with a
-          libsvn_client instead of acting as a wrapper around a
-          command-line program?  Besides simply being more efficient,
-          this can address potential correctness issues as well.  A
-          command-line program (like the one supplied with Subversion)
-          that binds to the client library needs to effectively
-          translate feedback and requested data bits from C types to
-          some form of human-readable output.  This type of
-          translation can be lossy.  That is, the program may not
-          display all of the information harvested from the API, or
-          may combine bits of information for compact representation.</para>
-        <para>If you wrap such a command-line program with yet another
-          program, the second program has access only to
-          already-interpreted (and as we mentioned, likely incomplete)
-          information, which it must <emphasis>again</emphasis>
-          translate into <emphasis>its</emphasis> representation
-          format.  With each layer of wrapping, the integrity of the
-          original data is potentially tainted more and more, much
-          like the result of making a copy of a copy (of a copy …)
-          of a favorite audio or video cassette.</para>
+        <para>如果你已经包裹了这样一个命令行程序,第二个程序只能访问已经经过解释的(如我们提到的,不完全)信息,需要<emphasis>再次</emphasis>转化为<emphasis>它本身的</emphasis>展示格式。由于各层的包裹,原始数据的完整性越来越难以保证,结果很像对喜欢的录音带或录像带反复的拷贝(一个拷贝…)。
+       </para>
@@ -800,7 +417,7 @@
   <!-- *** SECTION 2:  USING THE APIS                                  *** -->
   <!-- ******************************************************************* -->
   <sect1 id="svn-ch-8-sect-2">
-    <title>Using the APIs</title>
+    <title>使用API</title>
     <para>Developing applications against the Subversion library APIs
       is fairly straightforward.  All of the public header files live

Modified: trunk/src/zh/book/glossary.xml
--- trunk/src/zh/book/glossary.xml	(original)
+++ trunk/src/zh/book/glossary.xml	Fri Aug 19 23:14:25 2005
@@ -59,22 +59,32 @@
+      <glossentry>
+        <glossterm>delta(增量)</glossterm>
+        <glossdef>
+          <para>提交时只提交区别,也就是增量的模式</para>
+        </glossdef>
+      </glossentry>
-        <glossterm>dump format(导出格式)</glossterm>
+        <glossterm>directive(指示)</glossterm>
-          <para>从版本库里导出的文件的一种格式。</para>
+          <para>Apache配置文件中的配置选项</para>
-        <glossterm>delta(增量)</glossterm>
+        <glossterm>dump format(导出格式)</glossterm>
-          <para>提交时只提交区别,也就是增量的模式</para>
+          <para>从版本库里导出的文件的一种格式。</para>

More information about the svnbook-dev mailing list