Fix typos in various parts of the code.

9 files changed, 24 insertions, 24 deletions

diff --git a/source/fitz/bidi-std.c b/source/fitz/bidi-std.c
index 5d74d361..7315a88d 100644
--- a/source/fitz/bidi-std.c
+++ b/source/fitz/bidi-std.c
@@ -20,7 +20,7 @@
 	-----------
 
 	Sample Implementation of the Unicode Bidirectional Algorithm as it
-	was revised by Revision 5 of the Uniode Technical Report # 9
+	was revised by Revision 5 of the Unicode Technical Report # 9
 	(1999-8-17)
 
 	Verified for changes to the algorithm up through Unicode 5.2.0 (2009).
@@ -44,7 +44,7 @@
 	in UAX#9 had been clarified.
 
 	To see this code running in an actual Windows program,
-	download the free Unibook uitlity from http://unicode.org/unibook
+	download the free Unibook utility from http://unicode.org/unibook
 	The bidi demo is executed from the tools menu. It is build from
 	this source file.
 
@@ -131,7 +131,7 @@
 	3. Process the first paragraph by calling BidiParagraph. That
 	   function changes B into BN and returns a length including the
 	   paragraph separator. (The iteration over multiple paragraphs
-	   is left as excercise for the reader).
+	   is left as exercise for the reader).
 
 	4. Assign directional types again, but now assign specific types
 	   to whitespace characters.
@@ -152,7 +152,7 @@
 	reference implementation. Version 25 and its updates fix various
 	minor issues with the scaffolding used for demonstrating the
 	algorithm using pseudo-alphabets from the command line or dialog
-	box. No changes to the implementation of the actual bidi algrithm
+	box. No changes to the implementation of the actual bidi algorithm
 	are made in any of the minor updates to version 25. Version 26
 	also makes no change to the actual algorithm but was verified
 	against the official BidiTest.txt file for Unicode 5.2.0.
@@ -535,7 +535,7 @@ int fz_bidi_resolve_explicit(fz_bidi_level level, fz_bidi_chartype dir, fz_bidi_
 enum bidi_state // possible states
 {
 	xa,	//	arabic letter
-	xr,	//	right leter
+	xr,	//	right letter
 	xl,	//	left letter
 
 	ao,	//	arabic lett. foll by ON
@@ -625,7 +625,7 @@ const fz_bidi_action action_weak[][10] =
 {
 	//   N,.. L,   R,  AN,  EN,  AL, NSM,  CS,..ES,  ET,
 /*xa*/ { xxx, xxx, xxx, xxx, xxA, xxR, xxR, xxN, xxN, xxN }, /* arabic letter			*/
-/*xr*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxR, xxN, xxN, xIx }, /* right leter			 */
+/*xr*/ { xxx, xxx, xxx, xxx, xxE, xxR, xxR, xxN, xxN, xIx }, /* right letter			 */
 /*xl*/ { xxx, xxx, xxx, xxx, xxL, xxR, xxL, xxN, xxN, xIx }, /* left letter			 */
 
 /*ao*/ { xxx, xxx, xxx, xxx, xxA, xxR, xxN, xxN, xxN, xxN }, /* arabic lett. foll by ON	*/
@@ -667,7 +667,7 @@ fz_bidi_chartype get_resolved_type(fz_bidi_action action)
 
 	States can be of two kinds:
 	 - Immediate Resolution State, where each input token
-	   is resolved as soon as it is seen. These states havve
+	   is resolved as soon as it is seen. These states have
 	   only single action codes (xxN) or the no-op (xxx)
 	   for static input tokens.
 	 - Deferred Resolution State, where input tokens either
@@ -796,7 +796,7 @@ void fz_bidi_resolve_weak(fz_context *ctx, fz_bidi_level baselevel, fz_bidi_char
 		set_deferred_run(pcls, cch_run, ich, cls_run);
 }
 
-// === RESOLVE NEUTAL TYPES ==============================================
+// === RESOLVE NEUTRAL TYPES ==============================================
 
 // action values
 enum neutral_action
@@ -838,7 +838,7 @@ enum neutral_state
 	rn,	// N preceded by right
 	ln,	// N preceded by left
 	a,	// AN preceded by left (the abbrev 'la' is used up above)
-	na	// N preceeded by a
+	na	// N preceded by a
 } ;
 
 /*------------------------------------------------------------------------
@@ -958,7 +958,7 @@ void fz_bidi_resolve_neutrals(fz_bidi_level baselevel, fz_bidi_chartype *pcls, c
 		set_deferred_run(pcls, cch_run, ich, cls_run);
 }
 
-// === RESOLVE IMPLLICIT =================================================
+// === RESOLVE IMPLICITLY =================================================
 
 /*------------------------------------------------------------------------
 	Function: resolveImplicit
diff --git a/source/fitz/bidi.c b/source/fitz/bidi.c
index 1fda5656..7d3ca3a2 100644
--- a/source/fitz/bidi.c
+++ b/source/fitz/bidi.c
@@ -170,7 +170,7 @@ static fz_bidi_chartype class_from_ch_n(uint32_t ch)
 	return from_ch_ws;
 }
 
-/* Split fragments into single scripts (or punctation + single script) */
+/* Split fragments into single scripts (or punctuation + single script) */
 static void
 split_at_script(const uint32_t *fragment,
 		size_t fragment_len,
diff --git a/source/fitz/draw-affine.c b/source/fitz/draw-affine.c
index e9d11dab..9fd82950 100644
--- a/source/fitz/draw-affine.c
+++ b/source/fitz/draw-affine.c
@@ -3249,7 +3249,7 @@ fz_paint_image_imp(fz_pixmap * restrict dst, const fz_irect *scissor, const fz_p
 	/* TODO: if (fb == 0 && fa == 1) call fz_paint_span */
 
 	/* Sometimes we can get an alpha only input to be
-	 * ploted. In this case treat it as a greyscale
+	 * plotted. In this case treat it as a greyscale
 	 * input. */
 	if (img->n == sa && color)
 		sa = 0;
diff --git a/source/fitz/ftoa.c b/source/fitz/ftoa.c
index 4ec492e9..a16a9346 100644
--- a/source/fitz/ftoa.c
+++ b/source/fitz/ftoa.c
@@ -1,7 +1,7 @@
 #include "mupdf/fitz.h"
 
 /*
-	Convert IEEE single precison numbers into decimal ASCII strings, while
+	Convert IEEE single precision numbers into decimal ASCII strings, while
 	satisfying the following two properties:
 	1) Calling strtof or '(float) strtod' on the result must produce the
 	original float, independent of the rounding mode used by strtof/strtod.
@@ -166,7 +166,7 @@ static int
 k_comp(int n)
 {
 	/* Avoid ceil and floating point multiplication for better
-	 * performace and portability. Instead use the approximation
+	 * performance and portability. Instead use the approximation
 	 * log10(2) ~ 1233/(2^12). Tests show that this gives the correct
 	 * result for all values of n in the range -500..500. */
 	int tmp = n + DIY_SIGNIFICAND_SIZE - 1;
diff --git a/source/fitz/harfbuzz.c b/source/fitz/harfbuzz.c
index 0200c887..9afd9e40 100644
--- a/source/fitz/harfbuzz.c
+++ b/source/fitz/harfbuzz.c
@@ -27,7 +27,7 @@
  * harfbuzz instances.
  *
  * In order to ensure that allocations throughout mupdf
- * are done consistently, we get harfbuff to call our
+ * are done consistently, we get harfbuzz to call our
  * own hb_malloc/realloc/calloc/free functions that
  * call down to fz_malloc/realloc/calloc/free. These
  * require context variables, so we get our hb_lock
diff --git a/source/fitz/image.c b/source/fitz/image.c
index b3f684a0..59d09bf1 100644
--- a/source/fitz/image.c
+++ b/source/fitz/image.c
@@ -997,7 +997,7 @@ fz_image_resolution(fz_image *image, int *xres, int *yres)
 		*yres = *xres;
 	}
 
-	/* Scale xres and yres up until we get beleivable values */
+	/* Scale xres and yres up until we get believable values */
 	if (*xres < SANE_DPI || *yres < SANE_DPI || *xres > INSANE_DPI || *yres > INSANE_DPI)
 	{
 		if (*xres == *yres)
@@ -1051,7 +1051,7 @@ display_list_image_get_pixmap(fz_context *ctx, fz_image *image_, fz_irect *subar
 		pix = fz_new_pixmap(ctx, image->super.colorspace, w, h, 0);
 	}
 
-	/* If we render the displaylist into pix with the image matrix, we'll get a unit
+	/* If we render the display list into pix with the image matrix, we'll get a unit
 	 * square result. Therefore scale by w, h. */
 	ctm = image->transform;
 	fz_pre_scale(&ctm, w, h);
diff --git a/source/fitz/memento.c b/source/fitz/memento.c
index abb9f427..5619786d 100644
--- a/source/fitz/memento.c
+++ b/source/fitz/memento.c
@@ -207,7 +207,7 @@ static const char *eventType[] =
 /* When we list leaked blocks at the end of execution, we search for pointers
  * between blocks in order to be able to give a nice nested view.
  * Unfortunately, if you have are running your own allocator (such as
- * ghostscripts chunk allocator) you can often find that the header of the
+ * postscript's chunk allocator) you can often find that the header of the
  * block always contains pointers to next or previous blocks. This tends to
  * mean the nesting displayed is "uninteresting" at best :)
  *
@@ -564,7 +564,7 @@ typedef struct MY_SYMBOL_INFO {
     ULONG64     Reserved[2];
     ULONG       info;
     ULONG       Size;
-    ULONG64     ModBase;          // Base Address of module comtaining this symbol
+    ULONG64     ModBase;          // Base Address of module containing this symbol
     ULONG       Flags;
     ULONG64     Value;            // Value of symbol, ValuePresent should be 1
     ULONG64     Address;          // Address of symbol including base address of module
@@ -1420,7 +1420,7 @@ void Memento_info(void *addr)
 /* MacOSX has 10240, Ubuntu seems to have 256 */
 #define OPEN_MAX 10240
 
-/* stashed_map[j] = i means that filedescriptor i-1 was duplicated to j */
+/* stashed_map[j] = i means that file descriptor i-1 was duplicated to j */
 int stashed_map[OPEN_MAX];
 
 static void Memento_signal(void)
diff --git a/source/fitz/strtod.c b/source/fitz/strtod.c
index 7ab30fb2..27489ecd 100644
--- a/source/fitz/strtod.c
+++ b/source/fitz/strtod.c
@@ -106,7 +106,7 @@ fz_strtod(const char *as, char **aas)
 	flag = 0;	/* Fsign, Fesign, Fdpoint */
 	na = 0;		/* number of digits of a[] */
 	dp = 0;		/* na of decimal point */
-	ex = 0;		/* exonent */
+	ex = 0;		/* exponent */
 
 	state = S0;
 	for(s=(char*)as;; s++) {
diff --git a/source/fitz/strtof.c b/source/fitz/strtof.c
index a6f2f983..2020dafe 100644
--- a/source/fitz/strtof.c
+++ b/source/fitz/strtof.c
@@ -23,7 +23,7 @@
    4) Round x to a float using rounding mode 'to even'.
 
    Step 1) is always lossless as the strtof_fp_t's significand can hold a 9-digit integer.
-   In the case |dexp| <= 13 the cached power is exact and the algoritm returns
+   In the case |dexp| <= 13 the cached power is exact and the algorithm returns
    the exactly rounded result (with rounding mode 'to even').
    There is no double-rounding in 3), 4) as the multiply/divide uses 'round to odd'.
 
@@ -197,7 +197,7 @@ diy_to_float(strtof_fp_t x, int negative)
 	/* We have 2^32 - 2^8 = 0xffffff00.  */
 	else if (x.e > -158)
 	{
-		/* x is greator or equal to FLT_MAX. So we get a normalized number. */
+		/* x is greater or equal to FLT_MAX. So we get a normalized number. */
 		result = (uint32_t) (x.e + 158) << SP_SIGNIFICAND_SIZE;
 		result |= (x.f >> 8) & SP_SIGNIFICAND_MASK;
 
@@ -239,7 +239,7 @@ diy_to_float(strtof_fp_t x, int negative)
 	else if (x.e == -181 && x.f > 0x80000000)
 	{
 		/* x is in the range (0.5,1) *  2^-149 so it rounds to the smallest
-		   denormal. Cant't handle this in the previous case as shifting a
+		   denormal. Can't handle this in the previous case as shifting a
 		   uint32_t 32 bits to the right is undefined behaviour.  */
 		result = 1;
 	}