@matheusbsbs / matheus-bagliano / commits / 2ef8ac1b2a
Fork 0

manual: Fix or remove em dashes.

em dashes were used inconsistently in the manual. This changes them to the way they are used in US English. Signed-off-by: Lars Hjemli <hjemli@gmail.com> Signed-off-by: Shawn O. Pearce <spearce@spearce.org>

Ralf Wildenhues committed Oct 9, 2007 at 23:05 UTC 2ef8ac1b2a2d310642b8ae4dbec4b8173b4b1213
1 file changed +10 -10
Documentation/user-manual.txt
+10 -10
@@ -2756,7 +2756,7 @@ There are four different types of objects: "blob", "tree", "commit", and
2756 "blob" objects into a directory structure. In addition, a tree object
2757 can refer to other tree objects, thus creating a directory hierarchy.
2758 - A <<def_commit_object,"commit" object>> ties such directory hierarchies
2759 - together into a <<def_DAG,directed acyclic graph>> of revisions - each
2759 + together into a <<def_DAG,directed acyclic graph>> of revisions--each
2760 commit contains the object name of exactly one tree designating the
2761 directory hierarchy at the time of the commit. In addition, a commit
2762 refers to "parent" commit objects that describe the history of how we
@@ -3029,7 +3029,7 @@ There are also other situations that cause dangling objects. For
3029 example, a "dangling blob" may arise because you did a "git add" of a
3030 file, but then, before you actually committed it and made it part of the
3031 bigger picture, you changed something else in that file and committed
3032 -that *updated* thing - the old state that you added originally ends up
3032 +that *updated* thing--the old state that you added originally ends up
3033 not being pointed to by any commit or tree, so it's now a dangling blob
3034 object.
3035
@@ -3044,7 +3044,7 @@ up pointing to them, so they end up "dangling" in your repository.
3044 Generally, dangling objects aren't anything to worry about. They can
3045 even be very useful: if you screw something up, the dangling objects can
3046 be how you recover your old tree (say, you did a rebase, and realized
3047 -that you really didn't want to - you can look at what dangling objects
3047 +that you really didn't want to--you can look at what dangling objects
3048 you have, and decide to reset your head to some old dangling state).
3049
3050 For commits, you can just use:
@@ -3088,10 +3088,10 @@ $ git prune
3088 ------------------------------------------------
3089
3090 and they'll be gone. But you should only run "git prune" on a quiescent
3091 -repository - it's kind of like doing a filesystem fsck recovery: you
3091 +repository--it's kind of like doing a filesystem fsck recovery: you
3092 don't want to do that while the filesystem is mounted.
3093
3094 -(The same is true of "git-fsck" itself, btw - but since
3094 +(The same is true of "git-fsck" itself, btw, but since
3095 git-fsck never actually *changes* the repository, it just reports
3096 on what it found, git-fsck itself is never "dangerous" to run.
3097 Running it while somebody is actually changing the repository can cause
@@ -3482,7 +3482,7 @@ You write your current index file to a "tree" object with the program
3482 $ git write-tree
3483 -------------------------------------------------
3484
3485 -that doesn't come with any options - it will just write out the
3485 +that doesn't come with any options--it will just write out the
3486 current index into the set of tree objects that describe that state,
3487 and it will return the name of the resulting top-level tree. You can
3488 use that tree to re-generate the index at any time by going in the
@@ -3493,7 +3493,7 @@ object database -> index
3493 ~~~~~~~~~~~~~~~~~~~~~~~~
3494
3495 You read a "tree" file from the object database, and use that to
3496 -populate (and overwrite - don't do this if your index contains any
3496 +populate (and overwrite--don't do this if your index contains any
3497 unsaved state that you might want to restore later!) your current
3498 index. Normal operation is just
3499
@@ -3541,7 +3541,7 @@ Tying it all together
3541
3542 To commit a tree you have instantiated with "git-write-tree", you'd
3543 create a "commit" object that refers to that tree and the history
3544 -behind it - most notably the "parent" commits that preceded it in
3544 +behind it--most notably the "parent" commits that preceded it in
3545 history.
3546
3547 Normally a "commit" has one parent: the previous state of the tree
@@ -3684,7 +3684,7 @@ Once you know the three trees you are going to merge (the one "original"
3684 tree, aka the common tree, and the two "result" trees, aka the branches
3685 you want to merge), you do a "merge" read into the index. This will
3686 complain if it has to throw away your old index contents, so you should
3687 -make sure that you've committed those - in fact you would normally
3687 +make sure that you've committed those--in fact you would normally
3688 always do a merge against your last commit (which should thus match what
3689 you have in your current index anyway).
3690
@@ -3956,7 +3956,7 @@ Two things are interesting here:
3956
3957 - `get_sha1()` returns 0 on _success_. This might surprise some new
3958 Git hackers, but there is a long tradition in UNIX to return different
3959 - negative numbers in case of different errors -- and 0 on success.
3959 + negative numbers in case of different errors--and 0 on success.
3960
3961 - the variable `sha1` in the function signature of `get_sha1()` is `unsigned
3962 char \*`, but is actually expected to be a pointer to `unsigned