" Txtfmt: Set of Vim plugins (syntax, ftplugin, plugin) for creating and
" displaying formatted text with Vim.
" File: This is the global plugin file, which contains configuration code
" needed by both the ftplugin and the syntax files.
" Creation:	2004 Nov 06
" Last Change: 2010 Sep 18
" Maintainer:	Brett Pershing Stahlman <brettstahlman@comcast.net>
" License:	This file is placed in the public domain.

" Note: The following line is required by a packaging script
let g:Txtfmt_Version = "2.4"

" Autocommands needed by refresh mechanism <<<
au FileType * call s:Txtfmt_save_filetype()
au Syntax * call s:Txtfmt_save_syntax()
fu! s:Txtfmt_save_filetype()
	let l:filetype = expand("<amatch>")
	if l:filetype =~ '\%(^\|\.\)txtfmt\%(\.\|$\)'
		let b:txtfmt_filetype = l:filetype
	endif
endfu
fu! s:Txtfmt_save_syntax()
	let l:syntax = expand("<amatch>")
	if l:syntax =~ '\%(^\|\.\)txtfmt\%(\.\|$\)'
		let b:txtfmt_syntax = l:syntax
	endif
endfu
" >>>
" Constants needed regardless of whether common config is being performed <<<
" The following is passed to s:New_window() to construct the test page
let s:TESTPAGE_WINHEIGHT = 20
" >>>
" Functions needed regardless of whether common config is being performed <<<
" Function: s:Is_txtfmt_modeline() <<<
" Purpose: Return nonzero if and only if the line whose text is input "looks
" like" a txtfmt modeline.
" Note: Option names and values are NOT validated. That function is performed
" by s:Process_txtfmt_modeline.
" Inputs:
" linestr  -A line of text that may or may not represent a txtfmt modeline.
" Note: Format of the modeline is as follows:
" (Based upon 1st Vim modeline format)
"	[text]{white}txtfmt:[white]{options}
"	{options} can be the following:
"	{tokrange|rng}=<hex>|<dec>[sSlL]
"	{escape|esc}={self|bslash|none}
"	{sync}={<hex>|<dec>|fromstart|none}
"	{bgcolor|bg}=<color>
"	{nested|nst}
"	{concealcursor|cocu}=[n][v][i][c]
" Must be no whitespace surrounding the '='
" Also: Since Vim will not choke on a trailing ':' (though it's not
" technically part of the 1st modeline format), neither will I.
" Define regexes used to process modeline
" Also: ' txtfmt:' with no options is not an error, but will not be recognized
" as a modeline. Rationale: If user doesn't define any options in a modeline,
" assume it's just text that looks like the start of a modeline.
let s:re_ml_start = '\%(.\{-}\%(\s\+txtfmt:\s*\)\)'
let s:re_ml_name  = '\%(\I\i*\)'
let s:re_ml_val   = '\%(\%(\\.\|[^:[:space:]]\)*\)'
let s:re_ml_el    = '\%('.s:re_ml_name.'\%(='.s:re_ml_val.'\)\?\)'
let s:re_ml_elsep = '\%(\s\+\|\s*:\s*\)'
let s:re_ml_end   = '\%(\s*:\?\s*$\)'
" Construct pattern matching entire line, which will capture all leading text
" in \1, all options in \2, and all trailing text in \3
let s:re_modeline = '\('.s:re_ml_start.'\)\('
			\.s:re_ml_el.'\%('.s:re_ml_elsep.s:re_ml_el.'\)*\)'
			\.'\('.s:re_ml_end.'\)'
fu! s:Is_txtfmt_modeline(linestr)
	return a:linestr =~ s:re_modeline
endfu
" >>>
" Function: s:New_window <<<
" Description: Attempt to create display window of at least the
" specified size for things like test page and tutorial. If possible,
" don't change the height of existing windows (other than the current
" one). Note that this is easy to accomplish, even when 'ea' is set,
" because the `:N new' form effectively overrides 'ea'. If the current
" window is small, we may not be able to avoid shrinking the height of
" existing windows; fortunately, when the `:N new' form is used, Vim
" shrinks as few windows as possible, starting with the current one.
" Note On Size Calculation: Making a *precise" determination as to
" whether we could make the new window higher than requested height by
" halfing the current window would require special logic involving the
" 'laststatus' option. Fortunately, it is not necessary to make a
" precise determination. We can simply assume worst-case: i.e., the
" original winheight() will be reduced by 2 statuslines when the new
" window is created. This corresponds to the case in which 'laststatus'
" == 1, and there's only 1 window before the new one is created.
" Rationale: Using this simplification may result in our sometimes
" creating a window with exactly the requested height, when we might
" have made it a line or so higher, but this is not a problem, and the
" extra logic required to 'fix' it is not justified.
" Important Note: We need to check for error generated by the :new
" command. In particular, E36 will be generated if there's not enough
" space to create the new window. Note that the rules Vim uses to
" determine whether space is sufficient depend upon current setting of
" 'ea').
" Return: Nonzero on success, zero on failure
" Error: Set s:err_str and return zero
fu! s:New_window(height)
	let avail_height = winheight(0) - 2
	" Determine size of window to create
	if avail_height > 2 * a:height
		" Make test page half current window height (which should be >=
		" requested height)
		let create_height = avail_height / 2
	else
		" Make test page exactly the requested height
		let create_height = a:height
	endif
	" Create the window
	let v:errmsg = ''
	exe 'silent! ' . create_height . 'new'
	" Check for E36
	if v:errmsg != ''
		" Make error string available to caller and return false
		let s:err_str = v:errmsg
		return 0
	else
		" return true for Success
		return 1
	endif
endfu
" >>>
" >>>
" IMPORTANT NOTE: The common configuration code in this file is intended to be
" executed only upon request by either the txtfmt ftplugin or syntax file.
" Since this file resides in the Vim plugin directory, it will be sourced by
" Vim automatically whenever Vim is started; the common configuration code,
" however, will not be executed at Vim startup because the special txtfmt
" variable b:txtfmt_do_common_config will not be set at that time. When either
" the ftplugin or syntax file wishes to execute the code in this script, it
" sets b:txtfmt_do_common_config and uses :runtime to source this file. When
" the common configuration code within this file executes, it makes its output
" available to both ftplugin and syntax files via buffer-local variables.

if exists('b:txtfmt_do_common_config')
" Needed for both ftplugin and syntax
" Command: Refresh <<<
com! -buffer Refresh call s:Txtfmt_refresh()
" >>>
" Autocommands <<<
" Ensure that common configuration will be redone whenever the txtfmt buffer
" is re-read (e.g. after a txtfmt-modeline has been changed).
" Note: This autocmd allows user simply to do ":e" at the Vim command line to
" resource everything, including the option processing in common config.
augroup TxtfmtCommonConfig
	au BufReadPre <buffer> :unlet! b:txtfmt_did_common_config
augroup END
" >>>
" Common constant definitions <<<

" Define first Vim version that supported undercurl
let b:txtfmt_const_vimver_undercurl = 700
" Define several sets of constants needed by the functions used to process
" 'tokrange' option.
" Define tokrange defaults (decomposed into 'starttok' and 'formats' values)
" as a function of encoding class.
" Note: starttok encoded as string to preserve dec or hex display preference
let b:txtfmt_const_starttok_def_{'1'}    = '180'
let b:txtfmt_const_formats_def_{'1'}     = 'X'
let b:txtfmt_const_starttok_def_{'2'}    = '180'
let b:txtfmt_const_formats_def_{'2'}     = 'X'
let b:txtfmt_const_starttok_def_{'u'}    = '0xE000'
let b:txtfmt_const_formats_def_{'u'}     = 'X'
" Define the number of tokens in the txtfmt token range as a function of
" the format variant flags (which determine num_attributes in the equations
" below):
" --no background colors--
" N = 2 ^ {num_attributes} + 9
" --background colors--
" N = 2 ^ {num_attributes} + 9 + 9
" Important Note: The numbers are not dependent upon the number of active fg
" and bg colors, since we always reserve 8 colors.

" The 3 parameters in the following constants represent the following 3 format
" variant flags:
" txtfmt_cfg_bgcolor
" txtfmt_cfg_longformats
" txtfmt_cfg_undercurl
" Note: Value supplied for longformats and undercurl indices must take 'pack'
" option into account.
" TODO: Fix the final 3 elements or get rid of this array altogether. Note
" that it doesn't take 'pack' option into account
let b:txtfmt_const_tokrange_size_{0}{0}{0} = 17 
let b:txtfmt_const_tokrange_size_{0}{1}{0} = 41 
let b:txtfmt_const_tokrange_size_{0}{1}{1} = 73 
let b:txtfmt_const_tokrange_size_{1}{0}{0} = 26 
let b:txtfmt_const_tokrange_size_{1}{1}{0} = 82 
let b:txtfmt_const_tokrange_size_{1}{1}{1} = 82 

" Make sure we can easily deduce the suffix from the format variant flags
let b:txtfmt_const_tokrange_suffix_{0}{0}{0} = 'S'
let b:txtfmt_const_tokrange_suffix_{0}{1}{0} = 'L'
let b:txtfmt_const_tokrange_suffix_{0}{1}{1} = 'L'
let b:txtfmt_const_tokrange_suffix_{1}{0}{0} = 'X'
let b:txtfmt_const_tokrange_suffix_{1}{1}{0} = 'XL'
let b:txtfmt_const_tokrange_suffix_{1}{1}{1} = 'XL'

" Define the maximum character code that may be used as a txtfmt token as a
" function of encoding class. (Encoding class is specified as '1' for single
" byte, '2' for 16-bit and 'u' for unicode.)
" Note: Vim doesn't support unicode chars larger than 16-bit.
let b:txtfmt_const_tokrange_limit_{'1'} = 0xFF
let b:txtfmt_const_tokrange_limit_{'2'} = 0xFFFF
let b:txtfmt_const_tokrange_limit_{'u'} = 0xFFFF
" The following regex describes a {number} that may be used to set a numeric
" option. The txtfmt help specifies that only decimal or hexadecimal formats
" are permitted.
let b:txtfmt_re_number_atom = '\([1-9]\d*\|0x\x\+\)'

" >>>
" General utility functions <<<
" Function: s:Repeat() <<<
" Purpose: Generate a string consisting of the input string repeated the
" requested number of times.
" Note: Vim7 added a repeat() function, but I'm intentionally not using
" anything added post-Vim6.
" Input:
" str       - string to repeat
" cnt       - number of times to repeat it
" Return: The generated string
fu! s:Repeat(str, cnt)
	let ret_str = ''
	let i = 0
	while i < a:cnt
		let ret_str = ret_str . a:str
		let i = i + 1
	endwhile
	return ret_str
endfu
" >>>
" >>>
" Parse_<...> functions <<<
" Function: s:Parse_init()
" Purpose:
" Input:
" text		- string to be parsed
" re_tok	- regex matching a token
" Return: ID that must be passed to the other parse functions (-1 indicates
" error)
" Simulated struct:
" text
" len
" re
" pos
fu! s:Parse_init(text, re_tok)
	let i = 0
	let MAX_PARSE_INSTANCES = 1000
	while i < MAX_PARSE_INSTANCES
		if !exists('s:parsedata_'.i.'_text')
			" Found a free one
			let s:parsedata_{i}_text = a:text
			let s:parsedata_{i}_len = strlen(a:text)	" for speed
			let s:parsedata_{i}_re = a:re_tok
			let s:parsedata_{i}_pos = 0
			return i
		endif
		let i = i + 1
	endwhile
	if i >= MAX_PARSE_INSTANCES
		echoerr "Internal Parse_init error - contact developer"
		return -1
	endif
endfu
" Function: s:Parse_nexttok()
" Purpose:
" Input:
" Return: The next token as a string (or empty string if no more tokens)
" Error: Not possible when used correctly, and since this is an internally
" used function, we will not check for error.
fu! s:Parse_nexttok(parse_id)
	" Note: Structures used and generated internally in controlled manner, so
	" assume parse_id points to valid struct
	let text = s:parsedata_{a:parse_id}_text
	let re = s:parsedata_{a:parse_id}_re
	let pos = s:parsedata_{a:parse_id}_pos
	let len = s:parsedata_{a:parse_id}_len
	let parse_complete = 0	" set if text exhausted
	" Did last call exhaust text?
	if pos >= len
		let parse_complete = 1
		let ret_str = ''
	else
		" text not exhausted yet - get past any whitespace
		" ^\s* will return pos if no whitespace at pos (cannot return -1)
		let pos = matchend(text, '^\s*', pos)
		" Did we move past trailing whitespace?
		if pos >= len
			let parse_complete = 1
			let ret_str = ''
		else
			" We're sitting on first char to be returned.
			" re determines how many more will be part of return str
			" Note: Force re to match at current pos if at all
			let pos2 = matchend(text, '^'.re, pos)
			if pos2 < 0
				" curr char is not part of a token, so just return it by itself
				let ret_str = text[pos]
				let pos = pos + 1
			else
				" Return the token whose end was located
				let ret_str = strpart(text, pos, pos2-pos)
				let pos = pos2
			endif
		endif
	endif
	" Only way out of this function
	if parse_complete
		call s:Parse_free(a:parse_id)
	else
		" Update pos in structure for next call...
		let s:parsedata_{a:parse_id}_pos = pos
	endif
	return ret_str
endfu
" Function: s:Parse_free()
" Purpose: Free the data structures for a particular parse instance (denoted
" by input id)
" Input: parse_id - parse instance whose data is to be freed
" Return: none
" Error: not possible
fu! s:Parse_free(parse_id)
	" Using unlet! ensures that error not possible
	unlet! s:parsedata_{a:parse_id}_text
	unlet! s:parsedata_{a:parse_id}_re
	unlet! s:parsedata_{a:parse_id}_pos
	unlet! s:parsedata_{a:parse_id}_len

endfu
" >>>
" Configuration utility functions (common) <<<
" >>>
" encoding utility functions (common) <<<
let s:re_encs_1 = '^\%('
			\.'latin1\|iso-8859-n\|koi8-r\|koi8-u'
			\.'\|macroman\|cp437\|cp737\|cp775'
			\.'\|cp850\|cp852\|cp855\|cp857'
			\.'\|cp860\|cp861\|cp862\|cp863'
			\.'\|cp865\|cp866\|cp869\|cp874'
			\.'\|cp1250\|cp1251\|cp1253\|cp1254'
			\.'\|cp1255\|cp1256\|cp1257\|cp1258'
			\.'\)$'
let s:re_encs_2 = '^\%('
			\.'cp932\|euc-jp\|sjis\|cp949'
			\.'\|euc-kr\|cp936\|euc-cn\|cp950'
			\.'\|big5\|euc-tw'
			\.'\)'
let s:re_encs_u = '^\%('
			\.'utf-8\|ucs-2\|ucs-2le\|utf-16\|utf-16le\|ucs-4\|ucs-4le'
			\.'\)'
" Function: TxtfmtCommon_Encoding_get_class() <<<
" Purpose: Return single character indicating whether the input encoding name
" represents a 1-byte encoding ('1'), a 2-byte encoding ('2'), or a unicode
" encoding ('u'). If input encoding name is unrecognized, return empty string.
fu! TxtfmtCommon_Encoding_get_class(enc)
	if a:enc  =~ s:re_encs_1
		return '1'
	elseif a:enc =~ s:re_encs_2
		return '2'
	elseif a:enc =~ s:re_encs_u
		return 'u'
	else
		return ''
	endif
endfu
" >>>
" >>>
" 'tokrange' utility functions <<<
" Construct pattern that will capture char code in \1 and optional size
" specification (sSlLxX) in \2.
if exists('g:txtfmtAllowxl') && g:txtfmtAllowxl
	" Note: By default, XL suffix is illegal, but user has overridden the
	" default
	let s:re_tokrange_spec = '^\([1-9]\d*\|0x\x\+\)\(\%([sSlL]\|[xX][lL]\?\)\?\)$'
else
	let s:re_tokrange_spec = '^\([1-9]\d*\|0x\x\+\)\([sSlLxX]\?\)$'
endif

" Function: s:Tokrange_is_valid() <<<
" Purpose: Indicate whether input string is a valid tokrange spec.
fu! s:Tokrange_is_valid(spec)
	return a:spec =~ s:re_tokrange_spec
endfu
" >>>
" Function: s:Tokrange_get_formats() <<<
" Purpose: Return 'formats' component of the input tokrange spec.
" Note: If optional 'formats' component is omitted, empty string will be
" returned.
" Note: formats spec will be returned in canonical form (uppercase).
" Assumption: Input string has already been validated by s:Tokrange_is_valid.
fu! s:Tokrange_get_formats(spec)
	return substitute(a:spec, s:re_tokrange_spec, '\U\2', '')
endfu
" >>>
" Function: s:Tokrange_translate_tokrange() <<<
" Description: Decompose the input tokrange into its constituent parts,
" setting all applicable option variables:
" b:txtfmt_cfg_starttok
" b:txtfmt_cfg_bgcolor
" b:txtfmt_cfg_longformats
" b:txtfmt_cfg_undercurl
" b:txtfmt_cfg_starttok_display
" b:txtfmt_cfg_formats_display
fu! s:Tokrange_translate_tokrange(tokrange)
	" Extract starttok and formats from input tokrange
	let starttok_str = substitute(a:tokrange, s:re_tokrange_spec, '\1', '') 
	let formats_str = substitute(a:tokrange, s:re_tokrange_spec, '\2', '') 

	" Decompose starttok into a numeric and a display portion
	let b:txtfmt_cfg_starttok = 0 + starttok_str
	let b:txtfmt_cfg_starttok_display = starttok_str

	" Decompose formats into constituent flags and a display portion
	" Note: Formats is a bit special. For one thing, it can be omitted from a
	" tokrange spec, in which case we'll choose a default. Also, long formats
	" ('L') can mean either 'all' or 'all_but_undercurl', depending upon Vim
	" version and b:txtfmt_cfg_undercurlpref. (Undercurl was not supported
	" until Vim version 7.0, and we allow user to disable it with the
	" 'undercurl' option even when it is supported.)
	" Note: b:txtfmt_cfg_undercurl is always set explicitly to 0 when it
	" doesn't apply, so that it can be used in parameterized variable names.
	if strlen(formats_str) == 0
		" Format suffix was omitted. Default to 'extended' formats (background
		" colors with short formats)
		let b:txtfmt_cfg_bgcolor = 1
		let b:txtfmt_cfg_longformats = 0
		let b:txtfmt_cfg_undercurl = 0
		let b:txtfmt_cfg_formats_display = 'X'
	elseif formats_str ==? 'L'
		" Long formats with no background colors
		let b:txtfmt_cfg_bgcolor = 0
		let b:txtfmt_cfg_longformats = 1
		if v:version >= b:txtfmt_const_vimver_undercurl && b:txtfmt_cfg_undercurlpref
			let b:txtfmt_cfg_undercurl = 1
		else
			let b:txtfmt_cfg_undercurl = 0
		endif
		let b:txtfmt_cfg_formats_display = 'L'
	elseif formats_str ==? 'X'
		" Background colors with short formats
		let b:txtfmt_cfg_bgcolor = 1
		let b:txtfmt_cfg_longformats = 0
		let b:txtfmt_cfg_undercurl = 0
		let b:txtfmt_cfg_formats_display = 'X'
	elseif formats_str ==? 'XL'
		" Background colors with long formats
		let b:txtfmt_cfg_bgcolor = 1
		let b:txtfmt_cfg_longformats = 1
		if v:version >= b:txtfmt_const_vimver_undercurl && b:txtfmt_cfg_undercurlpref
			let b:txtfmt_cfg_undercurl = 1
		else
			let b:txtfmt_cfg_undercurl = 0
		endif
		" Note: This is no longer legal!!!!
		let b:txtfmt_cfg_formats_display = 'XL'
	else
		" Short formats
		let b:txtfmt_cfg_bgcolor = 0
		let b:txtfmt_cfg_longformats = 0
		let b:txtfmt_cfg_undercurl = 0
		let b:txtfmt_cfg_formats_display = 'S'
	endif
endfu
" >>>
" Function: s:Tokrange_size() <<<
" Note: Now that I'm reserving 8 colors even when numfgcolors and numbgcolors
" are less than 8, this function can probably be removed, or at least renamed
" (e.g., Tokrange_used_size).
fu! s:Tokrange_size(formats)
	return b:txtfmt_const_tokrange_size_{a:formats}
endfu
" >>>
" >>>
" 'sync' utility functions <<<
" Construct pattern that will validate the option value.
let s:re_sync_number_spec = '^\([1-9]\d*\|0x\x\+\)$'
let s:re_sync_name_spec = '^fromstart\|none$'

" Function: s:Sync_is_valid() <<<
" Purpose: Indicate whether input string is a valid sync option value
fu! s:Sync_is_valid(spec)
	return a:spec =~ s:re_sync_number_spec || a:spec =~ s:re_sync_name_spec
endfu
" >>>
" Function: s:Sync_get_method() <<<
" Purpose: Determine the syncmethod represented by the input sync value and
" return its name. Possible values: 'minlines', 'fromstart', 'none'
" Assumption: Input string has already been validated by s:Sync_is_valid.
fu! s:Sync_get_method(spec)
	if a:spec =~ s:re_sync_name_spec
		return a:spec
	else
		return 'minlines'
	endif
endfu
" >>>
" >>>
" 'escape' utility functions <<<
" Construct pattern that will validate the option value.
let s:re_escape_optval = '^\%(none\|bslash\|self\)$'
" Function: s:Escape_is_valid() <<<
" Purpose: Indicate whether input string is a valid escape option value
fu! s:Escape_is_valid(optval)
	return a:optval =~ s:re_escape_optval
endfu
" >>>
" >>>
" 'concealcursor' utility functions <<<
" Construct pattern that will validate the option value.
let s:re_concealcursor_optval = '^[nvic]*$'
" Function: s:Concealcursor_is_valid() <<<
" Purpose: Indicate whether input string is a valid concealcursor option value
fu! s:Concealcursor_is_valid(optval)
	return a:optval =~ s:re_concealcursor_optval
endfu
" >>>
" >>>
" Number validation utility functions <<<
" Function: s:Number_is_valid(s)
" Purpose: Indicate whether the input string represents a valid number
fu! s:Number_is_valid(s)
	return a:s =~ '^\s*'.b:txtfmt_re_number_atom.'\s*$'
endfu
" >>>
" Num fg/bg colors validation utility function <<<
let s:re_num_clrs = '^\%(0x\)\?[0-8]$'
fu! s:Numclrs_is_valid(s)
	return a:s =~ s:re_num_clrs
endfu
" >>>
" fg/bg color mask validation utility function <<<
let s:re_clr_mask = '^[01]\{8}$'
fu! s:Clrmask_is_valid(s)
	return a:s =~ s:re_clr_mask
endfu
" >>>
" Function: s:Set_tokrange() <<<
" Purpose: Set b:txtfmt_cfg_starttok, b:txtfmt_cfg_bgcolor,
" b:txtfmt_cfg_longformats and b:txtfmt_cfg_undercurl options, taking into
" account any user-setting of 'tokrange' option, and if necessary, the txtfmt
" defaults, which may take 'encoding' into consideration.
" Note: If set via modeline, tokrange option value must be a literal tokrange
" specification; however, buf-local and global option variables may be set to
" either a valid tokrange spec, or a Vim expression that evaluates to one.
" Permitting arbitrary Vim expressions facilitates the use of complex tokrange
" selection logic, implemented by a user-defined expression or function.
"  Examples:
"      'g:My_tokrange_calculator()'
"      '&enc == "utf-8" ? "1400l" : "130s"' 
fu! s:Set_tokrange()
	" Undef variables that are outputs of this function. Note that these
	" variables are the decomposition of b:txtfmt_cfg_tokrange, which may or
	" may not be set at this point.
	unlet! b:txtfmt_cfg_starttok
		\ b:txtfmt_cfg_bgcolor b:txtfmt_cfg_longformats b:txtfmt_cfg_undercurl
		\ b:txtfmt_cfg_starttok_display b:txtfmt_cfg_formats_display
	" Cache the 'encoding' in effect
	let enc = &encoding
	" Determine the corresponding encoding class
	let enc_class = TxtfmtCommon_Encoding_get_class(enc)
	if !exists('b:txtfmt_cfg_tokrange') || strlen(b:txtfmt_cfg_tokrange) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value.
		if exists('b:txtfmt_cfg_tokrange') && strlen(b:txtfmt_cfg_tokrange) == 0
			" Bad modeline set
			let l:warnmsg =
				\"Warning: Ignoring invalid modeline value for txtfmt `tokrange' option"
		elseif exists('b:txtfmtTokrange')
			" User overrode buf-local option. Save the option for validation
			" below...
			let b:txtfmt_cfg_tokrange = b:txtfmtTokrange
			let l:set_by = 'b'
		elseif exists('g:txtfmtTokrange')
			" User overrode global option. Save the option for validation
			" below...
			let b:txtfmt_cfg_tokrange = g:txtfmtTokrange
			let l:set_by = 'g'
		endif
	endif
	if exists('l:set_by') && (l:set_by == 'b' || l:set_by == 'g')
		" Perform special validation for buf-local/global settings, which
		" permits either a tokrange spec or a Vim expression that evaluates to
		" one.
		if !s:Tokrange_is_valid(b:txtfmt_cfg_tokrange)
			" Not a valid tokrange literal. Let's see whether it evaluates to
			" one.
			let v:errmsg = ''
			" Evaluate expression, using silent! to prevent problems in the
			" event that rhs is invalid.
			silent! exe 'let l:tokrange = '.b:txtfmt_cfg_tokrange
			if v:errmsg != ''
				" Bad expression
				let l:warnmsg =
					\"Warning: Ignoring invalid ".(l:set_by == 'b' ? 'buf-local' : 'global')
					\." value for txtfmt 'tokrange' option: ".b:txtfmt_cfg_tokrange
				" Discard the invalid setting
				let b:txtfmt_cfg_tokrange = ''
			else
				" It was a valid Vim expression. Did it produce a valid
				" tokrange spec?
				if !s:Tokrange_is_valid(l:tokrange)
					let l:warnmsg =
						\"Ignoring ".(l:set_by == 'b' ? 'buf-local' : 'global')
						\." set of txtfmt `tokrange' option: `".b:txtfmt_cfg_tokrange
						\."' produced invalid option value: ".l:tokrange
					" Discard the invalid setting
					let b:txtfmt_cfg_tokrange = ''
				else
					" Save the valid setting
					let b:txtfmt_cfg_tokrange = l:tokrange
				endif
			endif
		endif
	endif
	" Warn user if invalid user-setting is about to be overridden
	if exists('l:warnmsg')
		echoerr l:warnmsg
	endif
	" Decompose any valid user setting stored in b:txtfmt_cfg_tokrange.

	" Note: The output from the preceding stage is b:txtfmt_cfg_tokrange,
	" which we must now decompose into b:txtfmt_cfg_starttok,
	" b:txtfmt_cfg_bgcolor, b:txtfmt_cfg_longformats, b:txtfmt_cfg_undercurl,
	" b:txtfmt_cfg_starttok_display and b:txtfmt_cfg_formats_display. If
	" b:txtfmt_cfg_tokrange is nonexistent or null, there is no valid user
	" setting, in which case, we'll supply default.
	if exists('b:txtfmt_cfg_tokrange') && strlen(b:txtfmt_cfg_tokrange)
		" Decompose valid tokrange setting via s:Tokrange_translate_tokrange,
		" which sets all constituent variables.
		call s:Tokrange_translate_tokrange(b:txtfmt_cfg_tokrange)
		" Perform upper-bound validation
		if b:txtfmt_cfg_starttok +
			\ b:txtfmt_const_tokrange_size_{b:txtfmt_cfg_bgcolor}{b:txtfmt_cfg_longformats}{b:txtfmt_cfg_undercurl}
			\ - 1
			\ > b:txtfmt_const_tokrange_limit_{enc_class}
			" Warn user and use default
			echoerr
				\ "Warning: Tokrange value '".b:txtfmt_cfg_tokrange."' causes upper"
				\." bound to be exceeded for encoding ".&enc
			" Make sure we set to default below
			" Note: It suffices to unlet b:txtfmt_cfg_starttok, since its
			" nonexistence will ensure that all constituent vars are set below
			unlet! b:txtfmt_cfg_starttok
		endif
	endif
	" If b:txtfmt_cfg_starttok is still undefined, see whether there's an
	" encoding-specific default.
	" Note: b:txtfmt_cfg_starttok was unlet at the top of this function, so it
	" will be undefined unless it's been set successfully.
	if !exists('b:txtfmt_cfg_starttok')
		" TODO - Put any logic that depends upon specific encoding here...
		" .
		" .

	endif
	" If b:txtfmt_cfg_starttok is still undefined, see whether there's an
	" encoding-class-specific default.
	if !exists('b:txtfmt_cfg_starttok')
		" If encoding class is unrecognized, default to '1'
		if enc_class == ''
			let use_enc_class = '1'
		else
			let use_enc_class = enc_class
		endif
		" Pass default tokrange to function that will decompose it and set all
		" constituent variables.
		call s:Tokrange_translate_tokrange(
			\ b:txtfmt_const_starttok_def_{use_enc_class}
			\ . b:txtfmt_const_formats_def_{use_enc_class}
		\)
	endif
	" Note: If b:txtfmt_cfg_tokrange exists, we are done with it now that it
	" has been completely decomposed
	unlet! b:txtfmt_cfg_tokrange
	" Save the encoding class for later use (will be needed by Define_syntax
	" logic used to determine whether syn match offsets are byte or
	" char-based)
	let b:txtfmt_cfg_enc_class = enc_class
	" Also save encoding itself. If we're using a cached copy of encoding
	" class, we should be able to verify that the encoding upon which it is
	" based is the currently active one.
	let b:txtfmt_cfg_enc = enc
endfu
" >>>
" Function: s:Set_syncing() <<<
" Purpose: Set b:txtfmt_cfg_syncmethod and (if applicable) b:txtfmt_cfg_synclines
" options, according to the following logic:
" 1) If user set sync option via modeline, buffer-local option, or global
" option, attempt to use the setting with the highest priority.
" 2) If step 1 fails to set the option, either because of error or because the
" user made no attempt to set, default to minlines=250
" Note: From a user perspective, there is only the 'sync' option. For
" convenience within the plugin, we break this single option into two options:
" 'syncmethod' and 'synclines'. Currently, 'synclines' is used only when
" syncmethod=minlines.
fu! s:Set_syncing()
	if !exists('b:txtfmt_cfg_sync') || strlen(b:txtfmt_cfg_sync) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value.
		if exists('b:txtfmt_cfg_sync') && strlen(b:txtfmt_cfg_sync) == 0
			" Bad modeline set
			let l:bad_set_by = 'm'
		elseif exists('b:txtfmtSync')
			" User overrode buf-local option
			if s:Sync_is_valid(b:txtfmtSync)
				let b:txtfmt_cfg_sync = b:txtfmtSync
			else
				let l:bad_set_by = 'b'
			endif
		elseif exists('g:txtfmtSync')
			" User overrode global option
			if s:Sync_is_valid(g:txtfmtSync)
				let b:txtfmt_cfg_sync = g:txtfmtSync
			else
				let l:bad_set_by = 'g'
			endif
		endif
	endif
	" Warn user if invalid user-setting is about to be overridden
	if exists('l:bad_set_by')
		" Note: Display the offending option value for buf-local or global
		" option, but not for modeline, since modeline processing has already
		" reported the error.
		echoerr "Warning: Ignoring invalid ".(
			\ l:bad_set_by == 'm' ? "modeline" :
			\ l:bad_set_by == 'b' ? "buf-local" :
			\ "global") . " value for txtfmt `sync' option" . (
			\ l:bad_set_by == 'm' ? '' :
			\ l:bad_set_by == 'b' ? (': ' . b:txtfmtSync) :
			\ (': ' . g:txtfmtSync))
	endif
	if !exists('b:txtfmt_cfg_sync') || strlen(b:txtfmt_cfg_sync) == 0
		" Set to default
		let b:txtfmt_cfg_syncmethod = 'minlines'
		let b:txtfmt_cfg_synclines = 250
	else
		" Decompose validated 'sync' option into 'syncmethod' and (if
		" applicable) 'synclines'
		let b:txtfmt_cfg_syncmethod = s:Sync_get_method(b:txtfmt_cfg_sync)
		if b:txtfmt_cfg_syncmethod == 'minlines'
			" Save the number of lines
			let b:txtfmt_cfg_synclines = (0 + b:txtfmt_cfg_sync)
		endif
	endif
	" We're done with b:txtfmt_cfg_sync now that it has been completely
	" decomposed.
	unlet! b:txtfmt_cfg_sync
endfu
" >>>
" Function: s:Translate_color_optstr() <<<
" Purpose: Process the string representing a single element from the array
" txtfmtColor{1..8}, and return the extracted information.
" Return: A comma-separated string containing the extracted information as
" follows:
" <namepat>,<ctermfg_rhs>,<guifg_rhs>
" Note that ctermfg_rhs and/or guifg_rhs may be blank, in the event that user
" specified term patterns and none of them matched. (If no term patterns are
" specified, there is an implied match with current &term value.)
" Note that return string will have commas and backslashes escaped.
" Note that the last color def that matches for each of guifg and ctermfg is
" the one that is returned to caller.
" Error: Set s:err_str and return empty string
" Details:
" Here is the format of a single string in the txtfmtColor{} array:
" <namepat>,<clrdef1>[,<clrdef2>,...,<clrdefN>]
" <clrdef> :=
" 	<c|g>[<termpatlist>]:<clrstr>
" 	<termpatlist> :=
" 		:<termpat1>:<termpat2>:...:<termpatN>
" *** Parse table ***
" st	next_st		can_end?	tok
" 0		1			n			<namepat>
" 1		2			n			,
" 2		3			n			<c|g>
" 3		4			n			:
" 4		5			n			str
" 5		4			y			:
" 5		2			y			,
" Example color optstr:
" red,c:xterm:dosterm:DarkRed,g:builtin_gui:other_gui:#FF0000
"
" Here are the meanings of the fields:
" <namepat>	-regex used to recognize the token used to specify a
" 	certain color; e.g., when prompted by one of the insert token maps. May
" 	not contain spaces or commas.
" 	Example: k\|b\%[lack]
" <c|g>				-specifies whether clrstr will be the rhs of a
" 	"ctermfg=" ('c'), or "guifg=" ('g')
" <termpat>	-pattern used to match against &term option. It is a regex pattern
" 	which will be applied as ^<termpat>$
" <clrstr>	-rhs of a "ctermfg=" or "guifg=" assignment.
" 	:help gui-colors | help cterm-colors
" Additional Note:
" Commas, colons, and backslashes appearing in fields must be
" backslash-escaped.
" Note: Due to the extra backslash escaping, it is recommended to use a
" string-literal, rather than double-quoted string.
fu! s:Translate_color_optstr(optstr)
	" optstr is the string to be parsed
	" Initialize the state machine
	let pst = 0
	" Initialize the parse engine to consider tokens to be broken only at
	" unescaped commas and colons.
	let pid = s:Parse_init(a:optstr, '\%(\\.\|[^,:]\)\+')
	if pid < 0
		let s:err_str = 'Internal error within s:Translate_color_optstr(). Contact developer.'
		echomsg 'Internal error'
		return ''
	endif
	" Extract and handle tokens in a loop
	let parse_complete = 0
	" The following 2 will be set in loop (hopefully at least 1 anyways)
	let ctermfg_rhs = ''
	let guifg_rhs = ''
	while !parse_complete
		let tok = s:Parse_nexttok(pid)
		" Note: Could handle end of string here for states in which end of
		" string is illegal - but that would make it more difficult to
		" formulate meaningful error messages.
		"if tok == '' && pst != 5
		"endif
		" Switch on the current state
		if pst == 0	" Extract non empty namepat
			let namepat = substitute(tok, '\\\(.\)', '\1', 'g')
			if namepat =~ '^[[:space:]]*$'
				let s:err_str = "Color def string must contain at least 1 non-whitespace char"
				return ''
			endif
			let pst = 1
		elseif pst == 1
			if tok == ','
				let pst = 2
			elseif tok == ''
				let s:err_str = "Expected comma, encountered end of color def string"
				return ''
			else
				let s:err_str = "Expected comma, got '".tok."'"
				return ''
			endif
		elseif pst == 2
			if tok == 'c' || tok == 'g'
				let pst = 3
				let c_or_g = tok
				" Do some initializations for this cterm/gui
				let tp_or_cs_cnt = 0
				let got_term_match = 0
			elseif tok == ''
				let s:err_str = "Expected 'c' or 'g', encountered end of color def string"
				return ''
			else
				let s:err_str = "Expected 'c' or 'g', got '".tok."'"
				return ''
			endif
		elseif pst == 3
			if tok == ':'
				let pst = 4
			elseif
				let s:err_str = "Expected ':', encountered end of color def string"
				return ''
			else
				let s:err_str = "Expected ':', got '".tok."'"
				return ''
			endif
		elseif pst == 4
			let pst = 5
			" Do some processing with this and possibly previous termpat or
			" clrstr token. Note that if previous one exists, it is termpat;
			" we can't yet know what current one is.
			let termpat_or_clrstr = substitute(tok, '\\\(.\)', '\1', 'g')
			if termpat_or_clrstr =~ '^[[:space:]]*$'
				let s:err_str = "Term patterns and color strings must contain at least one non-whitespace char"
				return ''
			endif
			" If here, update the count. Note that we won't know whether this
			" is termpat or clrstr until next time here.
			let tp_or_cs_cnt = tp_or_cs_cnt + 1
			if !got_term_match && tp_or_cs_cnt > 1
				" Process saved string as termpat
				" Pattern has implied ^ and $. Also, termpat may contain \c
				if &term =~ '^'.tp_or_cs_str.'$'
					" Found a match!
					let got_term_match = 1
				endif
			endif
			" Save current token for processing next time
			let tp_or_cs_str = termpat_or_clrstr
		elseif pst == 5
			if tok == ':'		" another termpat or clrstr
				let pst = 4
			elseif tok == ',' 	" another cterm/gui
				let pst = 2
			elseif tok == ''	" end of string - legal in state 5
				let parse_complete = 1
			else				" illegal token
				let s:err_str = "Unexpected input in color def string: ".tok
				return ''
			endif
			if tok == ',' || tok == ''
				" Need to process saved data from pst 4, which we now know to
				" be a clrstr.
				if tp_or_cs_cnt == 1 || got_term_match
					" Either no termpats were specified (implied match with
					" &term) or one of the termpats matched.
					" Note that prior ctermfg/guifg rhs strings may be
					" overwritten here, if more than one cterm/gui def exists
					" and has a match.
					if c_or_g == 'c'
						let ctermfg_rhs = tp_or_cs_str
					else
						let guifg_rhs = tp_or_cs_str
					endif
				endif
			endif
		endif
	endwhile
	" Construct the return string:
	" <namepat>,<ctermfg_rhs>,<guifg_rhs>
	let ret_str = escape(namepat, ',\').','
		\.escape(ctermfg_rhs, ',\').','.escape(guifg_rhs, ',\')
	return ret_str
endfu
" >>>
" Function: s:Get_color_uniq_idx() <<<
" Purpose: Convert the rhs of b:txtfmt_clr and b:txtfmt_bgc (if applicable) to
" a single string. Look the string up in global array
" g:txtfmt_color_configs{}. If the color config already exists, return its
" index; otherwise, append the color config to a new element at the end of
" g:txtfmt_color_configs{}, and return the corresponding index.
" Note: The index returned will be used to ensure that the highlight groups
" used for this buffer are specific to the color configuration.
" Input: none
" Return: Uniqueness index corresponding to the color configuration stored in
" b:txtfmt_clr and b:txtfmt_bgc (if applicable). In the unlikely event that no
" colors are active in the current configuration (i.e., numfgcolors and
" numbgcolors both equal 0), we return an empty string.
fu! s:Get_color_uniq_idx()
	" Build the string to be looked up
	let s = ''
	let fgbg_idx = 0
	let clr_or_bgc{0} = 'clr'
	let clr_or_bgc{1} = 'bgc'
	let fg_or_bg{0} = 'fg'
	let fg_or_bg{1} = 'bg'
	while fgbg_idx < (b:txtfmt_cfg_bgcolor ? 2 : 1)
		" Loop over all used colors
		" TODO_BG: Does it make sense to include unused ones? It shouldn't be
		" necessary...
		" Note: Index 1 corresponds to first non-default color
		let i = 1
		while i <= b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors
			let s = s.b:txtfmt_{clr_or_bgc{fgbg_idx}}{i}."\<NL>"
			let i = i + 1
		endwhile
		let fgbg_idx = fgbg_idx + 1
	endwhile
	" In the unlikely event that string is still empty, config is such that no
	" colors are in use, in which case, we return an empty string, since no
	" uniqueness index applies.
	if strlen(s) == 0
		return ''
	endif
	" Look up the newly-generated string in g:txtfmt_color_configs
	if !exists('g:txtfmt_color_configs_len')
		let g:txtfmt_color_configs_len = 0
	endif
	let i = 0
	while i < g:txtfmt_color_configs_len
		if g:txtfmt_color_configs{i} == s
			" Color config exists already - return its index
			return i
		endif
		let i = i + 1
	endwhile
	" If here, color config doesn't exist yet, so append it
	let g:txtfmt_color_configs{i} = s
	let g:txtfmt_color_configs_len = g:txtfmt_color_configs_len + 1
	" Return index of appended element
	return i
endfu
" >>>
" Function: s:Process_color_options() <<<
" Purpose: Process the special color definition arrays to determine the color
" arrays in effect for the current buffer. There are global and buffer-local
" versions of both txtfmtColor and txtfmtBgcolor, as well as a default in
" s:txtfmt_clr. From these, we construct the 8 element buf-local arrays,
" described under 'Return:' below.
" Algorithm: Each color index is considered independently of all others, with
" a buf-local definition taking precedence over a global one. A txtfmtBgcolor
" element is always preferred for background color, but txtfmtColor will be
" used for a background color when no background-color-specific element
" exists. If no other element can be found, defaults from s:txtfmt_clr will be
" used.
" Cterm and gui may be overridden separately, and color definition strings may
" even take into account the value of &term. Note that for each possible
" element in the array, there is a default element (in s:txtfmt_clr{1..8}),
" which will be used if user has not overriden.
" Return: indirect only
" Builds the following buffer-scope arrays: (indexed by 1-based color index)
" b:txtfmt_clr_namepat{}, b:txtfmt_clr{}
" b:txtfmt_bgc_namepat{}, b:txtfmt_bgc{}
" Note: bgc arrays will not be built if background colors are disabled.
" Details: The format of the color array is as follows:
" The array has 8 elements (1..8), each of which represents a color region
" begun with one of the 8 successive color tokens in the token range. Each
" element is a string whose format is described in header of
" s:Translate_color_optstr()
" Rules: In outer loop over fg and bg cases, and inner loop over all color
" indices in range i = 1..8, check all applicable variants of the txtfmtColor
" array (as defined in arrname{}) for an element corresponding to the current
" color index. Set b:txtfmt_clr{} and move to next color index as soon as a
" suitable definition is found. Suitability is determined by checking
" has('gui_running') against the 'g:' or 'c:' in the color definition string,
" and if necessary, by matching the current value of 'term' against a 'term'
" pattern in the color definition string.
" Note: This function was rewritten on 10May2008, and then again on 31Jan2009.
" A corresponding partial rewrite of s:Translate_color_optstr is probably in
" order, but is not necessary, so I've left the latter function completely
" intact for now. (We don't really need both ctermfg and guifg values any
" more, but s:Translate_color_optstr still returns both...)
fu! s:Process_color_options()
	let arrname{0} = 'b:txtfmtBgcolor'
	let arrname{1} = 'g:txtfmtBgcolor'
	let arrname{2} = 'b:txtfmtColor'
	let arrname{3} = 'g:txtfmtColor'
	let arrname{4} = 's:txtfmt_clr'
	" TODO_BG: Decide whether s:txtfmt_bgc should be removed - if so, may get
	" rid of arr_end{}
	" Define strings used to build appropriate var names for both fg and bg
	let clr_or_bgc{0} = 'clr'
	let clr_or_bgc{1} = 'bgc'
	" Frame the array for fg and bg
	" Note: Could use a common value for end.
	let arr_beg{0} = 2
	let arr_end{0} = 4
	let arr_beg{1} = 0
	let arr_end{1} = 4
	" Determine arrays that don't apply to fg color
	let skip{0}_{0} = 1
	let skip{0}_{1} = 1
	let skip{0}_{2} = 0
	let skip{0}_{3} = 0
	let skip{0}_{4} = 0
	if b:txtfmt_cfg_bgcolor
		" Determine arrays that don't apply to bg color
		let skip{1}_{0} = 0
		let skip{1}_{1} = 0
		let skip{1}_{2} = 0
		let skip{1}_{3} = 0
		let skip{1}_{4} = 0
	endif
	" Loop over fg and bg color (if applicable)
	let fgbg_idx = 0
	while fgbg_idx < (b:txtfmt_cfg_bgcolor ? 2 : 1)
		let i = 1
		" Loop over all colors (1st non-default color at index 1)
		while i < b:txtfmt_num_colors
			" Init strings to value signifying not specified or error
			let namepat = '' | let clr_rhs = ''
			" Loop over the possible color arrays
			let j = arr_beg{fgbg_idx}
			while j <= arr_end{fgbg_idx}
				" Skip inapplicable arrays
				if skip{fgbg_idx}_{j}
					let j = j + 1
					continue
				endif
				" Skip nonexistent color definitions
				if exists(arrname{j}.'{'.i.'}')
					exe 'let l:el = '.arrname{j}.'{'.i.'}'
					" If here, color definition exists. Let's see whether it contains
					" a match...
					let s = s:Translate_color_optstr(el)
					if s != ''
						" Extract fields from the escaped return string (which is
						" internally generated, and hence, does not require
						" validation)
						" TODO - Perhaps standardize this in one spot (function or
						" static return variables)
						let re_fld = '\%(\%(\\.\|[^,]\)*\)'
						let re_sfld = '\(\%(\\.\|[^,]\)*\)'
						let namepat = substitute(s, re_sfld.'.*', '\1', '')
						if has('gui_running')
							let clr_rhs = substitute(s, re_fld.','.re_fld.','.re_sfld, '\1', '')
						else
							let clr_rhs = substitute(s, re_fld.','.re_sfld.'.*', '\1', '')
						endif
						" Note: clr_rhs may be null at this point; if so, there
						" was no applicable color definition, though the color def
						" element was valid
						if strlen(clr_rhs)
							" Remove extra level of backslashes
							let namepat = substitute(namepat, '\\\(.\)', '\1', 'g')
							let clr_rhs = substitute(clr_rhs, '\\\(.\)', '\1', 'g')
						endif
					elseif arrname{j}[0] == 'b' || arrname{j}[0] == 'g'
						echomsg "Ignoring invalid user-specified color def ".arrname{j}.i." due to error: "
							\.s:err_str
					else
						" Shouldn't get here! Problem with defaults...
						echomsg "Internal error within Process_color_options - bad default for txtfmtColors"
							\.i." - contact developer."
					endif
					" Are we done yet?
					if strlen(clr_rhs)
						break
					endif
				endif
				let j = j + 1
			endwhile
			" Assumption: Lack of color rhs at this point implies internal error.
			" Build the buffer-specific array used in syntax file...
			" Note: In the following 2 arrays, an index of 1 corresponds to the
			" first non-default color.
			let b:txtfmt_{clr_or_bgc{fgbg_idx}}_namepat{i} = namepat
			let b:txtfmt_{clr_or_bgc{fgbg_idx}}{i} = clr_rhs
			" Advance to next color
			let i = i + 1
		endwhile
		let fgbg_idx = fgbg_idx + 1
	endwhile
	" Now that the color configuration is completely determined (and loaded
	" into b:txtfmt_clr{} (and b:txtfmt_bgc{} if applicable)), determine the
	" 'uniqueness index' for this color configuration. The uniqueness index is
	" used to ensure that each color configuration has its own set of syntax
	" groups.
	" TODO_BG: Is the _cfg_ infix appropriate for such variables? For now, I'm
	" using it only for option vars (with one exception that needs looking at)
	let b:txtfmt_color_uniq_idx = s:Get_color_uniq_idx()
endfu
" >>>
" Function: s:Process_txtfmt_modeline() <<<
" Purpose: Determine whether input line is a valid txtfmt modeline. Process
" options if so. If required by s:txtfmt_ml_new_<...> variables, change
" options in the modeline itself. (Example: change 'tokrange' as requested by
" preceding call to :MoveStartTok command.)
" Note: Input line may be either a valid line number or a string representing
" a valid modeline (which is constructed by the caller)
" Return:
" 0		- no txtfmt modeline found
" -1	- txtfmt modeline containing error (bad option)
" 1		- valid txtfmt modeline found and processed
" Note: Modeline format is described under function s:Is_txtfmt_modeline.
fu! s:Process_txtfmt_modeline(line)
	if a:line =~ '^[1-9][0-9]*$'
		" Obtain the line to be processed
		let l:line = a:line
		let linestr = getline(a:line)
	else
		" The line to be processed is not in the buffer
		let l:line = 0
		let linestr = a:line
	endif
	" Is the line a modeline?
	if !s:Is_txtfmt_modeline(linestr)
		" Note: This is not considered error - the line is simply not a
		" modeline
		return 0
	endif
	" If here, overall format is correct. Are all options valid?
	" Assume valid modeline until we find out otherwise...
	let ret_val = 1
	" Save the leading text, in case we need to create a version of the line
	" with changed options (e.g., starttok change)
	let leading = substitute(linestr, s:re_modeline, '\1', '')
	" The middle (options) part will be built up as we go
	let middle = ''
	" Save the trailing stuff
	let trailing = substitute(linestr, s:re_modeline, '\3', '')
	" Extract the {options} portion (leading/trailing stuff removed) for
	" processing
	let optstr = substitute(linestr, s:re_modeline, '\2', '')
	" Extract pieces from head of optstr as long as unprocessed options exist
	" Note: The following pattern may be used to extract element separators
	" into \1, opt name into \2, equal sign (if it exists) into \3, opt value
	" (if it exists) into \4, and to strip all three from the head of the
	" string. (The remainder of the modeline will be in \5.)
	" Note: Element separator is optional in the following re, since it won't
	" exist for first option, and we've already verified that it exists
	" between all other options.
	let re_opt = '\('.s:re_ml_elsep.'\)\?\('
				\.s:re_ml_name.'\)\%(\(=\)\('.s:re_ml_val.'\)\)\?\(.*\)'
	" If this is a real buffer line, do some special processing required only
	" when modeline options are being changed or added
	if l:line > 0
		" Set this flag if we make a requested change to an option, which needs to
		" be reflected in the actual modeline text in the buffer (e.g., starttok
		" change)
		unlet! line_changed
		" If we haven't done so already, save location at which new options can be
		" added.
		if !exists('s:txtfmt_ml_addline')
			let s:txtfmt_ml_addline = l:line
			" Note: The +1 changes 0-based byte index to 1-based col index
			" Note: Saved value represents the col number of the first char to be
			" added
			let s:txtfmt_ml_addcol = matchend(linestr, s:re_ml_start) + 1
		endif
	endif
	" Loop over all options, exiting loop early if error occurs
	while strlen(optstr) > 0 && ret_val != -1
		" Accumulate the option separator text
		let middle = middle.substitute(optstr, re_opt, '\1', '')
		" Extract option name and value
		let optn = substitute(optstr, re_opt, '\2', '')
		let has_eq = '=' == substitute(optstr, re_opt, '\3', '')
		let optv = substitute(optstr, re_opt, '\4', '')
		" Remove the option about to be processed from head of opt str
		let optstr = substitute(optstr, re_opt, '\5', '')
		" IMPORTANT TODO: The following if/else needs major refactoring to
		" avoid duplication. There are ways of doing this that require far
		" less brute-force. I'm saving it for a subsequent release to mitigate
		" testing.
		" Validate the option(s)
		if optn == 'tokrange' || optn == 'rng'
			"format: tokrange=<char_code>[sSlLxX]
			"Examples: '130s' '1500l' '130' '0x2000L'
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'tokrange'"
				let b:txtfmt_cfg_tokrange = ''
				let ret_val = -1
			elseif !s:Tokrange_is_valid(optv)
				" 2 cases when option is invalid:
				" 1) We can fix the invalid tokrange by changing to the value
				"    specified by user in call to :MoveStartTok
				" 2) We must display error and use default
				if exists('s:txtfmt_ml_new_starttok')
					" Design Decision: Since option value is not valid, don't
					" attempt to preserve any existing 'formats' specifier
					" Assumption: b:txtfmt_cfg_bgcolor,
					" b:txtfmt_cfg_longformats, and b:txtfmt_cfg_undercurl are
					" unlet *only* at the top of Set_tokrange; thus, we can
					" assume they will be valid here.
					let optv = s:txtfmt_ml_new_starttok
						\.b:txtfmt_const_tokrange_suffix_{b:txtfmt_cfg_bgcolor}{b:txtfmt_cfg_longformats}{b:txtfmt_cfg_undercurl}
					" Record fact that change was made
					unlet s:txtfmt_ml_new_starttok
					let line_changed = 1
				else
					let s:err_str = "Invalid 'tokrange' value - must be hex or dec"
								\." char code value optionally followed by one of [sSlLxX]"
					" Note: 'XL' suffix is currently illegal, but give a special
					" warning if user attempts to use it.
					if optv =~? 'xl$'
						let s:err_str = s:err_str
							\." (The XL suffix is currently illegal, due to a memory resource limitation"
							\." affecting current versions of Vim; this suffix may, however, be supported in"
							\." a future release.)"
					endif
					" Record the attempt to set b:txtfmt_cfg_tokrange from modeline
					let b:txtfmt_cfg_tokrange = ''
					let ret_val = -1
				endif
			else
				if exists('s:txtfmt_ml_new_starttok')
					" Change the starttok value, preserving both the starttok
					" number format (note that s:txtfmt_ml_new_starttok is
					" actually a string) and any existing 'formats'
					" specification
					" Note: Since modeline setting trumps all others, an
					" existing setting should agree with current setting
					" anyway.
					let optv = substitute(optv, b:txtfmt_re_number_atom, s:txtfmt_ml_new_starttok, '')
					" Record fact that change was made
					unlet s:txtfmt_ml_new_starttok
					let line_changed = 1
				endif
				" Save the option value, deferring processing till later...
				let b:txtfmt_cfg_tokrange = optv
			endif
		elseif optn == 'fgcolormask' || optn == 'fcm'
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'fgcolormask'"
				let b:txtfmt_cfg_fgcolormask = ''
				let ret_val = -1
			elseif !s:Clrmask_is_valid(optv)
				" Invalid number of colors
				let s:err_str = "Invalid foreground color mask - must be string of 8 ones and zeroes"
				let b:txtfmt_cfg_fgcolormask = ''
				let ret_val = -1
			else
				let b:txtfmt_cfg_fgcolormask = optv
			endif
		elseif optn == 'bgcolormask' || optn == 'bcm'
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'bgcolormask'"
				let b:txtfmt_cfg_bgcolormask = ''
				let ret_val = -1
			elseif !s:Clrmask_is_valid(optv)
				" Invalid number of colors
				let s:err_str = "Invalid background color mask - must be string of 8 ones and zeroes"
				let b:txtfmt_cfg_bgcolormask = ''
				let ret_val = -1
			else
				let b:txtfmt_cfg_bgcolormask = optv
			endif
		elseif optn == 'sync'
			"format: sync={<hex>|<dec>|fromstart|none}
			"Examples: 'sync=300' 'sync=0x1000' 'sync=fromstart' 'sync=none'
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'sync'"
				let b:txtfmt_cfg_sync = ''
				let ret_val = -1
			elseif !s:Sync_is_valid(optv)
				let s:err_str = "Invalid 'sync' value - must be one of the"
							\." following: <numeric literal>, 'fromstart'"
							\.", 'none'"
				" Record the attempt to set b:txtfmt_cfg_sync from modeline
				let b:txtfmt_cfg_sync = ''
				let ret_val = -1
			else
				" Defer processing of sync till later
				let b:txtfmt_cfg_sync = optv
			endif
		elseif optn =~ '^\(no\)\?\(pack\|pck\)$'
			" Make sure no option value was supplied to binary option
			if has_eq
				let s:err_str = "Cannot assign value to boolean txtfmt option 'pack'"
				let b:txtfmt_cfg_pack = ''
				let ret_val = -1
			else
				" Option has been explicitly turned on or off
				let b:txtfmt_cfg_pack = optn =~ '^no' ? 0 : 1
			endif
		elseif optn =~ '^\(no\)\?\(undercurl\|uc\)$'
			" Make sure no option value was supplied to binary option
			if has_eq
				let s:err_str = "Cannot assign value to boolean txtfmt option 'undercurl'"
				let b:txtfmt_cfg_undercurlpref = ''
				let ret_val = -1
			else
				" Option has been explicitly turned on or off
				let b:txtfmt_cfg_undercurlpref = optn =~ '^no' ? 0 : 1
			endif
		elseif optn =~ '^\(no\)\?\(nested\|nst\)$'
			" Make sure no option value was supplied to binary option
			if has_eq
				let s:err_str = "Cannot assign value to boolean txtfmt option 'nested'"
				let b:txtfmt_cfg_nested = ''
				let ret_val = -1
			else
				" Option has been explicitly turned on or off
				let b:txtfmt_cfg_nested = optn =~ '^no' ? 0 : 1
			endif
		elseif optn =~ '^\(no\)\?\(conceal\|cncl\)$'
			" Make sure no option value was supplied to binary option
			if has_eq
				let s:err_str = "Cannot assign value to boolean txtfmt option 'conceal'"
				let b:txtfmt_cfg_conceal = ''
				let ret_val = -1
			else
				" Option has been explicitly turned on or off
				let b:txtfmt_cfg_conceal = optn =~ '^no' || !has('conceal') ? 0 : 1
			endif
		elseif optn == 'concealcursor' || optn == 'cocu'
			" format: cocu=[n][v][i][c]
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'concealcursor'"
				let b:txtfmt_cfg_concealcursor_invalid = 1
				let ret_val = -1
			elseif !s:Concealcursor_is_valid(optv)
				let s:err_str = "Invalid 'concealcursor' option: `" . optv
					\ . "' - only the following flags are permitted: nvic"
				" Note: This one is different from the others: empty string is
				" valid option value, so we can't use null string to indicate
				" error
				let b:txtfmt_cfg_concealcursor_invalid = 1
				let ret_val = -1
			else
				" Option has been explicitly set
				" Vim Issue: With 'concealcursor', duplicate flags aren't
				" removed as they are for other such options (and as
				" documentation indicates they should be).
				" Note: Intentially skipping check for duplicates since
				" they're harmless.
				let b:txtfmt_cfg_concealcursor = optv
			endif
		elseif optn == 'escape' || optn == 'esc'
			"format: escape=[bslash|self|none]
			"TODO: Perhaps use s:Escape_is_valid() for validation
			if !has_eq
				let s:err_str = "Value required for non-boolean txtfmt option 'escape'"
				let b:txtfmt_cfg_escape = ''
				let ret_val = -1
			elseif optv == 'bslash'
				let b:txtfmt_cfg_escape = 'bslash'
			elseif optv == 'self'
				let b:txtfmt_cfg_escape = 'self'
			elseif optv == 'none'
				let b:txtfmt_cfg_escape = 'none'
			else
				let s:err_str = "Invalid 'escape' value - must be 'bslash', 'self', or 'none'"
				let b:txtfmt_cfg_escape = ''
				let ret_val = -1
			endif
		else
		   let s:err_str = "Unknown txtfmt modeline option: ".optn
		   let ret_val = -1
		endif
		" Append optn[=optv] to middle
		let middle = middle . optn . (has_eq ? '=' . optv : '')
	endwhile
	" Processed txtfmt modeline without error
	if l:line > 0 && exists('line_changed')
		" Alter the line to reflect any option changes
		" Note: If error occurred above, optstr may be non-empty, in which
		" case, we need to append it to the already processed options in
		" middle.
		call setline(l:line, leading.middle.optstr.trailing)
	endif
	return ret_val
endfu
" >>>
" Function: s:Do_txtfmt_modeline() <<<
" Purpose: Look for txtfmt "modelines" of the following form:
" .\{-}<whitespace>txtfmt:<definitions>:
" which appear within the first or last 'modelines' lines in the buffer.
" Note: Function will search a number of lines (at start and end of buffer),
" as determined from 'modelines', provided that this value is nonzero. If
" 'modelines' is 0, default of 5 lines at beginning and end will be searched.
" Return:
" 0     - no txtfmt modeline found
" N     - N valid txtfmt modelines found and processed
" -N    - txtfmt modeline processing error occurred on the Nth modeline
"         processed
" Error_handling: If error is encountered in a modeline, the remainder of
" the offending modeline is discarded, and modeline processing is aborted;
" i.e., no more lines are searched. This is consistent with the way Vim's
" modeline processing works.
" Modeline_modifications: The following buf-local variables are considered to
" be inputs that request changes to existing modelines:
" b:txtfmt_ml_new_starttok
" ...
" If the requested change can't be made, we will attempt to add the requested
" setting to an existing modeline. If there are no existing modelines, we will
" add a new one (warning user if he has modeline processing turned off). If
" modifications are made to the buffer, we will use b:txtfmt_ml_save_modified
" to determine whether the buffer was in a modified state prior to our
" changes, and will save our changes if and only if doing so doesn't commit
" any unsaved user changes.
" Assumption: Another Txtfmt function sets b:txtfmt_ml_save_modified
" appropriately before the Txtfmt-initiated changes begin.
fu! s:Do_txtfmt_modeline()
	" Check for request to change starttok
	if exists('b:txtfmt_ml_new_starttok')
		" Communicate the request to modeline processing function.
		let s:txtfmt_ml_new_starttok = b:txtfmt_ml_new_starttok
		" Unlet the original to ensure that if we abort with error, we don't
		" do this next time
		unlet! b:txtfmt_ml_new_starttok
	else
		" Clean up after any previous failed attempts
		unlet! s:txtfmt_ml_new_starttok
	endif
	" Did someone anticipate that we might be modifying the buffer?
	if exists('b:txtfmt_ml_save_modified')
		let l:save_modified = b:txtfmt_ml_save_modified
		unlet b:txtfmt_ml_save_modified
	endif
	" The following apply to any option change request. They're set within
	" Process_txtfmt_modeline the first time a suitable add location is found
	unlet! s:txtfmt_ml_addline
	unlet! s:txtfmt_ml_addcol

	" Keep up with # of modelines actually encountered
	let l:ml_seen = 0
	" How many lines should we search?
	" Priority is given to txtfmtModelines user option if it exists
	if exists('b:txtfmtModelines') || exists('g:txtfmtModelines')
		" User can disable by setting to 0
		let mls_use = exists('b:txtfmtModelines') ? b:txtfmtModelines : g:txtfmtModelines
	else
		" Use 'modelines' option+1 unless it's not a valid nonzero value, in
		" which case, we use default of 5
		" NOTE: 1 is added to 'modelines' option so that if modeline is at
		" highest or lowest possible line, putting a txtfmt modeline above or
		" below it, respectively, will work.
		let mls_use = &modelines > 0 ? &modelines+1 : 5
	endif
	let nlines = line('$')
	" Check first modelines lines
	" TODO - Combine the 2 loops into one, which can alter the loop counter in
	" a stepwise manner.
	let i = 1
	while i <= mls_use && i <= nlines
		let status = s:Process_txtfmt_modeline(i)
		if status == 1
			 " Successfully extracted options
			 let l:ml_seen = l:ml_seen + 1
		elseif status == -1
			 " Error processing the modeline
			 echoerr "Ignoring txtfmt modeline on line ".i.": ".s:err_str
			 return -(l:ml_seen + 1)
		endif
		" Keep looking...
		let i = i + 1
	endwhile
	" Check last modelines lines
	let i = nlines - mls_use + 1
	" Adjust if necessary to keep from checking already checked lines
	if i <= mls_use
		let i = mls_use + 1
	endif
	while i <= nlines
		let status = s:Process_txtfmt_modeline(i)
		if status == 1
			 " Successfully extracted options
			 let l:ml_seen = l:ml_seen + 1
		elseif status == -1
			 " Error processing the modeline
			 echoerr "Ignoring txtfmt modeline on line ".i.": ".s:err_str
			 return -(l:ml_seen + 1)
		endif
		" Keep looking...
		let i = i + 1
	endwhile
	" Deal with any unprocessed requests for modeline option changes
	" Note: Process_txtfmt_modeline unlets s:txtfmt_ml_new_<...> vars that
	" have been completely handled.
	let l:ml_new_opts = ''
	if exists('s:txtfmt_ml_new_starttok')
		" TODO: Decide whether it matters that this strategy will put a
		" useless space at end of modeline in the unlikely event that the
		" original modeline contained no options
		" Assumption: b:txtfmt_cfg_bgcolor, b:txtfmt_cfg_longformats, and
		" b:txtfmt_cfg_undercurl are unlet *only* at the top of Set_tokrange;
		" thus, we can assume they will be valid here.
		let l:ml_new_opts = l:ml_new_opts
			\.'tokrange='
			\.s:txtfmt_ml_new_starttok
			\.b:txtfmt_const_tokrange_suffix_{b:txtfmt_cfg_bgcolor}{b:txtfmt_cfg_longformats}{b:txtfmt_cfg_undercurl}
			\.' '
	endif
	" Any additional requests would go here
	" ...
	" Do we have any options to add?
	if strlen(l:ml_new_opts)
		" Create the modeline that will be passed to Process_txtfmt_modeline
		let l:ml_process = "\<Tab>txtfmt:".l:ml_new_opts
		" Add what needs to be added to the buffer
		if exists('s:txtfmt_ml_addline')
			" Add new options to existing modeline
			let linestr = getline(s:txtfmt_ml_addline)
			" Recreate the line
			call setline(s:txtfmt_ml_addline,
				\ strpart(linestr, 0, s:txtfmt_ml_addcol - 1)
				\ . l:ml_new_opts
				\ . strpart(linestr, s:txtfmt_ml_addcol - 1))
		else
			" Create a new txtfmt modeline on first line. Note that it's the
			" same as what will be passed to Process_txtfmt_modeline for
			" processing.
			call append(0, l:ml_process)
			if mls_use == 0
				" Warn user that he should change his modelines setting
				" TODO_BG: Figure out how to prevent the warning from
				" disappearing after a second or two.
				echomsg "Warning: Txtfmt has added option settings to a modeline at the beginning"
					\." of the buffer, but your modeline setting is such that this modeline"
					\." will be ignored next time the buffer is opened."
					\." (:help txtfmtModelines)"
			endif
			" Record fact that we've processed another modeline
			let l:ml_seen = l:ml_seen + 1
		endif
		" Process only the options just added
		let status = s:Process_txtfmt_modeline(l:ml_process)
		" Note: Error should be impossible here, but just in case...
		if status < 0
			echoerr "Internal error: Unexpected error while processing txtfmt-generated modeline: ".s:err_str.". Contact the developer"
			return -(l:ml_seen)
		elseif status == 0
			echoerr "Internal error: Failed to extract option(s) while processing txtfmt-generated modeline. Contact the developer"
			return -(l:ml_seen)
		endif
	endif
	" If modeline processing made an unmodified buffer modified, save our
	" changes now. (Rationale: Leave the buffer in the state it was in prior
	" to modeline processing. This avoids making user's unsaved changes
	" permanent.)
	if exists('l:save_modified') && !l:save_modified && &modified
		write
	endif
	" If here, we encountered no error. Return the number of modelines
	" processed (could be zero)
	return l:ml_seen
endfu
" >>>
" Function: s:Process_clr_masks() <<<
" Inputs:
" b:txtfmt_cfg_fgcolormask
" b:txtfmt_cfg_bgcolormask
" Description: Each mask is a string of 8 chars, each of which must be either
" '0' or '1'
" Outputs:
" b:txtfmt_cfg_fgcolor{} b:txtfmt_cfg_numfgcolors
" b:txtfmt_cfg_bgcolor{} b:txtfmt_cfg_numbgcolors
" Description: The <fg|bg>color arrays are 1-based indirection arrays, which
" contain a single element for each of the active colors. The elements of
" these arrays are the 1-based indices of the corresponding color in the
" actual color definition array (which always contains 8 elements).
" Note: num<fg|bg>colors will be 0 and corresponding array will be empty if
" there are no 1's in the <fg|bg>colormask
" Note: If 'tokrange' setting precludes background colors, the bg colormask
" option will be all 0's at this point, regardless of how user has configured
" the option.
fu! s:Process_clr_masks()
	" Loop over fg and bg
	let fgbg_idx = 0
	let fg_or_bg{0} = 'fg'
	let fg_or_bg{1} = 'bg'
	while fgbg_idx < 2
		" Cache the mask to be processed
		let mask = b:txtfmt_cfg_{fg_or_bg{fgbg_idx}}colormask
		" Note: To be on the safe side, I'm going to zero the bg color mask
		" whenever bg colors are disabled, just in case caller forgot.
		if fg_or_bg{fgbg_idx} == 'bg' && !b:txtfmt_cfg_bgcolor && mask =~ '1'
			let mask = '00000000'
		endif
		" Loop over all 8 'bits' in the mask
		" Assumption: The mask length has already been validated
		" Note: All color arrays processed are 1-based (since index 0, if it
		" exists, corresponds to 'no color'), but mask bit 'array' is
		" inherently 0-based (because it's a string)
		let i = 0
		let iadd = 0
		while i < 8
			if mask[i] == '1'
				" Append this color's (1-based) index to active color array
				" (which is also 1-based)
				let iadd = iadd + 1
				let b:txtfmt_cfg_{fg_or_bg{fgbg_idx}}color{iadd} = i + 1
			endif
			let i = i + 1
		endwhile
		" Store number of active colors
		let b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors = iadd
		" Prepare for next iteration
		let fgbg_idx = fgbg_idx + 1
	endwhile
endfu
" >>>
" Function: s:Define_fmtclr_vars() <<<
fu! s:Define_fmtclr_vars()
	" Format definition array <<<
	" NOTE: This array is used for rhs of syntax definitions, but also for display
	" by ShowTokenMap.
	let b:txtfmt_fmt{0}  = 'NONE'
	let b:txtfmt_fmt{1}  = 'underline'
	let b:txtfmt_fmt{2}  = 'bold'
	let b:txtfmt_fmt{3}  = 'underline,bold'
	let b:txtfmt_fmt{4}  = 'italic'
	let b:txtfmt_fmt{5}  = 'underline,italic'
	let b:txtfmt_fmt{6}  = 'bold,italic'
	let b:txtfmt_fmt{7}  = 'underline,bold,italic'
	if !b:txtfmt_cfg_longformats
		" short formats
		let b:txtfmt_num_formats = 8
	else
		" long formats
		let b:txtfmt_fmt{8}  = 'standout'
		let b:txtfmt_fmt{9}  = 'underline,standout'
		let b:txtfmt_fmt{10} = 'bold,standout'
		let b:txtfmt_fmt{11} = 'underline,bold,standout'
		let b:txtfmt_fmt{12} = 'italic,standout'
		let b:txtfmt_fmt{13} = 'underline,italic,standout'
		let b:txtfmt_fmt{14} = 'bold,italic,standout'
		let b:txtfmt_fmt{15} = 'underline,bold,italic,standout'
		let b:txtfmt_fmt{16} = 'reverse'
		let b:txtfmt_fmt{17} = 'underline,reverse'
		let b:txtfmt_fmt{18} = 'bold,reverse'
		let b:txtfmt_fmt{19} = 'underline,bold,reverse'
		let b:txtfmt_fmt{20} = 'italic,reverse'
		let b:txtfmt_fmt{21} = 'underline,italic,reverse'
		let b:txtfmt_fmt{22} = 'bold,italic,reverse'
		let b:txtfmt_fmt{23} = 'underline,bold,italic,reverse'
		let b:txtfmt_fmt{24} = 'standout,reverse'
		let b:txtfmt_fmt{25} = 'underline,standout,reverse'
		let b:txtfmt_fmt{26} = 'bold,standout,reverse'
		let b:txtfmt_fmt{27} = 'underline,bold,standout,reverse'
		let b:txtfmt_fmt{28} = 'italic,standout,reverse'
		let b:txtfmt_fmt{29} = 'underline,italic,standout,reverse'
		let b:txtfmt_fmt{30} = 'bold,italic,standout,reverse'
		let b:txtfmt_fmt{31} = 'underline,bold,italic,standout,reverse'
		" If using undercurl (introduced in Vim 7.0), there will be twice as
		" many formats.
		if !b:txtfmt_cfg_undercurl
			let b:txtfmt_num_formats = 32
		else
			let b:txtfmt_fmt{32} = 'undercurl'
			let b:txtfmt_fmt{33} = 'underline,undercurl'
			let b:txtfmt_fmt{34} = 'bold,undercurl'
			let b:txtfmt_fmt{35} = 'underline,bold,undercurl'
			let b:txtfmt_fmt{36} = 'italic,undercurl'
			let b:txtfmt_fmt{37} = 'underline,italic,undercurl'
			let b:txtfmt_fmt{38} = 'bold,italic,undercurl'
			let b:txtfmt_fmt{39} = 'underline,bold,italic,undercurl'
			let b:txtfmt_fmt{40} = 'standout,undercurl'
			let b:txtfmt_fmt{41} = 'underline,standout,undercurl'
			let b:txtfmt_fmt{42} = 'bold,standout,undercurl'
			let b:txtfmt_fmt{43} = 'underline,bold,standout,undercurl'
			let b:txtfmt_fmt{44} = 'italic,standout,undercurl'
			let b:txtfmt_fmt{45} = 'underline,italic,standout,undercurl'
			let b:txtfmt_fmt{46} = 'bold,italic,standout,undercurl'
			let b:txtfmt_fmt{47} = 'underline,bold,italic,standout,undercurl'
			let b:txtfmt_fmt{48} = 'reverse,undercurl'
			let b:txtfmt_fmt{49} = 'underline,reverse,undercurl'
			let b:txtfmt_fmt{50} = 'bold,reverse,undercurl'
			let b:txtfmt_fmt{51} = 'underline,bold,reverse,undercurl'
			let b:txtfmt_fmt{52} = 'italic,reverse,undercurl'
			let b:txtfmt_fmt{53} = 'underline,italic,reverse,undercurl'
			let b:txtfmt_fmt{54} = 'bold,italic,reverse,undercurl'
			let b:txtfmt_fmt{55} = 'underline,bold,italic,reverse,undercurl'
			let b:txtfmt_fmt{56} = 'standout,reverse,undercurl'
			let b:txtfmt_fmt{57} = 'underline,standout,reverse,undercurl'
			let b:txtfmt_fmt{58} = 'bold,standout,reverse,undercurl'
			let b:txtfmt_fmt{59} = 'underline,bold,standout,reverse,undercurl'
			let b:txtfmt_fmt{60} = 'italic,standout,reverse,undercurl'
			let b:txtfmt_fmt{61} = 'underline,italic,standout,reverse,undercurl'
			let b:txtfmt_fmt{62} = 'bold,italic,standout,reverse,undercurl'
			let b:txtfmt_fmt{63} = 'underline,bold,italic,standout,reverse,undercurl'
			let b:txtfmt_num_formats = 64
		endif
	endif
	" >>>
	" <<< Default color definition array
	" These are the original defaults
	let s:txtfmt_clr{1} = '^\\%(k\\|bla\\%[ck]\\)$,c:Black,g:#000000'
	let s:txtfmt_clr{2} = '^b\\%[lue]$,c:DarkBlue,g:#0000FF'
	let s:txtfmt_clr{3} = '^g\\%[reen]$,c:DarkGreen,g:#00FF00'
	let s:txtfmt_clr{4} = '^t\\%[urquoise]$,c:DarkCyan,g:#00FFFF'
	let s:txtfmt_clr{5} = '^r\\%[ed]$,c:DarkRed,g:#FF0000'
	let s:txtfmt_clr{6} = '^v\\%[iolet]$,c:DarkMagenta,g:#FF00FF'
	let s:txtfmt_clr{7} = '^y\\%[ellow]$,c:DarkYellow,g:#FFFF00'
	let s:txtfmt_clr{8} = '^w\\%[hite]$,c:White,g:#FFFFFF'
	" Note: The following variable indicates the total number of colors
	" possible, including 'no color', which is not in the txtfmt_clr array.
	" TODO: See how this is used to see how to use numfgcolors and numbgcolors...
	let b:txtfmt_num_colors = 9
	" >>>
	" Set fmt/clr specific values for convenience
	" txtfmt_<rgn>_first_tok:      1st (default) token
	" txtfmt_<rgn>_last_tok:       last (reserved) token
	" txtfmt_last_tok:             last token that could be used (if
	"                              txtfmt_cfg_numbgcolors is applicable,
	"                              assumes it to be 8)
	" TODO NOTE - If desired, could allow the fmt/clr ranges to be split, in
	" which case, the following 2 would be user-configurable. For now, just
	" base them on txtfmtStarttok.
	" TODO: Decide whether to keep this here or move outside this function
	call s:Process_clr_masks()
	" Save some useful char codes
	let b:txtfmt_clr_first_tok = b:txtfmt_cfg_starttok
	let b:txtfmt_clr_last_tok = b:txtfmt_cfg_starttok + b:txtfmt_num_colors - 1
	let b:txtfmt_fmt_first_tok = b:txtfmt_clr_last_tok + 1
	let b:txtfmt_fmt_last_tok = b:txtfmt_fmt_first_tok + b:txtfmt_num_formats - 1
	if b:txtfmt_cfg_bgcolor
		" Location of bg color range depends upon 'pack' setting as well
		" as well as type of formats in effect
		" Note: Intentionally hardcoding bgcolor index to 0 and undercurl
		" index to 1 (when formats are long) to get desired length
		" TODO: Replace ternaries with normal if block
		let b:txtfmt_bgc_first_tok = b:txtfmt_cfg_starttok +
			\ b:txtfmt_const_tokrange_size_{0}{
				\(b:txtfmt_cfg_longformats || !b:txtfmt_cfg_pack ? 1 : 0)}{
				\(b:txtfmt_cfg_longformats || !b:txtfmt_cfg_pack ? 1 : 0)}
		let b:txtfmt_bgc_last_tok = b:txtfmt_bgc_first_tok + b:txtfmt_num_colors - 1
		let b:txtfmt_last_tok = b:txtfmt_bgc_last_tok
	else
		" nothing after the fmt range
		let b:txtfmt_bgc_first_tok = -1
		let b:txtfmt_bgc_last_tok = -1
		let b:txtfmt_last_tok = b:txtfmt_fmt_last_tok
	endif
endfu
" >>>
" Function: s:Define_fmtclr_regexes() <<<
" Purpose: Define regexes involving the special fmt/clr tokens.
" Assumption: The following variable(s) has been defined for the buffer:
" b:txtfmt_cfg_starttok
" Note: The start tok is user-configurable. Thus, this function should be
" called only after processing options.
fu! s:Define_fmtclr_regexes()
	" Cache bgc enabled flag for subsequent tests
	let bgc = b:txtfmt_cfg_bgcolor && b:txtfmt_cfg_numbgcolors > 0
	let clr = b:txtfmt_cfg_numfgcolors > 0
	" 0 1 3 4 5 7 8
	"   1 3 4 5 7 8
	let fgbg_idx = 0
	let clr_or_bgc{0} = 'clr' | let fg_or_bg{0} = 'fg'
	let clr_or_bgc{1} = 'bgc' | let fg_or_bg{1} = 'bg'
	while fgbg_idx < 2
		if b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors
			" Note: Handle first active color here, outside the loop. To handle it
			" inside the loop, I would need to initialize tok_cnt to 0 and tok_i
			" to -1 and handle tok_i == -1 specially within the loop. (tok_i == -1
			" indicates that we don't have the potential beginning of a range)
			let tok_i = b:txtfmt_cfg_{fg_or_bg{fgbg_idx}}color{1}
			let tok_cnt = 1
			let i = 2 " first active color already accounted for
			" Initialize regex string to be built within loop
			let b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom = ''
			" Loop over active colors (and one fictitious element past end of
			" array). Note that first active color was handled in initializations.
			while i <= b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors + 1
				" We know something is ending (atom or range) if any of the
				" following conditions is true:
				" -We're on the non-existent element one past end of active color
				"  array
				" -The current active color index is not 1 greater than the last
				" TODO_BG: Can't compare with tok_i + 1 since tok_i isn't
				" updated through range.
				if i >= b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors + 1 || (b:txtfmt_cfg_{fg_or_bg{fgbg_idx}}color{i} != tok_i + tok_cnt)
					" Something is ending
					if tok_cnt > 1
						" Append range if more than 2 chars; otherwise, make
						" it a double atom.
						let b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom = b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom
							\.nr2char(b:txtfmt_{clr_or_bgc{fgbg_idx}}_first_tok + tok_i)
							\.(tok_cnt > 2 ? '-' : '')
							\.nr2char(b:txtfmt_{clr_or_bgc{fgbg_idx}}_first_tok + tok_i + tok_cnt - 1)
					else
						" Append atom
						let b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom = b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom
							\.nr2char(b:txtfmt_{clr_or_bgc{fgbg_idx}}_first_tok + tok_i)
					endif
					" Start something new unless at end
					if i <= b:txtfmt_cfg_num{fg_or_bg{fgbg_idx}}colors
						let tok_cnt = 1
						let tok_i = b:txtfmt_cfg_{fg_or_bg{fgbg_idx}}color{i}
					endif
				else
					" Nothing is ending - record continuation
					let tok_cnt = tok_cnt + 1
				endif
				let i = i + 1
			endwhile
			" Create the _tok_ version from the _stok_ version by prepending
			" default (end) token
			" Decision Needed: Do I want to create tok this way, or would it be
			" better to gain a slight bit of highlighting efficiency in some cases
			" by putting the default tok into a range if possible.
			" Note: I'm leaning against this optimization. Consider that it would
			" be possible only for color configurations in which the first color
			" is active; hence, if there were any speed difference in the
			" highlighting (and a significant one is doubtful in my opinion), it
			" would depend upon the specific color masks, which seems inconsistent
			" and therefore inappropriate.
			let b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_tok_atom =
				\ nr2char(b:txtfmt_{clr_or_bgc{fgbg_idx}}_first_tok)
				\ . b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_stok_atom
			let b:txtfmt_re_{clr_or_bgc{fgbg_idx}}_etok_atom =
				\ nr2char(b:txtfmt_{clr_or_bgc{fgbg_idx}}_first_tok)
		endif
		let fgbg_idx = fgbg_idx + 1
	endwhile
	" Format region tokens
	let b:txtfmt_re_fmt_tok_atom = nr2char(b:txtfmt_fmt_first_tok).'-'.nr2char(b:txtfmt_fmt_last_tok)
	let b:txtfmt_re_fmt_stok_atom = nr2char(b:txtfmt_fmt_first_tok + 1).'-'.nr2char(b:txtfmt_fmt_last_tok)
	let b:txtfmt_re_fmt_etok_atom = nr2char(b:txtfmt_fmt_first_tok)
	" Color regions that include inactive colors
	if clr
		let b:txtfmt_re_CLR_tok_atom = nr2char(b:txtfmt_clr_first_tok).'-'.nr2char(b:txtfmt_clr_last_tok)
		let b:txtfmt_re_CLR_stok_atom = nr2char(b:txtfmt_clr_first_tok + 1).'-'.nr2char(b:txtfmt_clr_last_tok)
		let b:txtfmt_re_CLR_etok_atom = nr2char(b:txtfmt_clr_first_tok)
	endif
	if bgc
		let b:txtfmt_re_BGC_tok_atom = nr2char(b:txtfmt_bgc_first_tok).'-'.nr2char(b:txtfmt_bgc_last_tok)
		let b:txtfmt_re_BGC_stok_atom = nr2char(b:txtfmt_bgc_first_tok + 1).'-'.nr2char(b:txtfmt_bgc_last_tok)
		let b:txtfmt_re_BGC_etok_atom = nr2char(b:txtfmt_bgc_first_tok)
	endif
	" Combined regions
	let b:txtfmt_re_any_tok_atom =
				\(clr ? b:txtfmt_re_clr_tok_atom : '')
				\.nr2char(b:txtfmt_fmt_first_tok).'-'.nr2char(b:txtfmt_fmt_last_tok)
				\.(bgc ? b:txtfmt_re_bgc_tok_atom : '')
	" TODO: Perhaps get rid of dependence upon b:txtfmt_clr_last_tok?
	" TODO: Refactor to use newly-created CLR and BGC atoms
	let b:txtfmt_re_ANY_tok_atom =
				\(clr ? nr2char(b:txtfmt_clr_first_tok).'-'.nr2char(b:txtfmt_clr_last_tok) : '')
				\.nr2char(b:txtfmt_fmt_first_tok).'-'.nr2char(b:txtfmt_fmt_last_tok)
				\.(bgc ? nr2char(b:txtfmt_bgc_first_tok).'-'.nr2char(b:txtfmt_bgc_last_tok) : '')
	let b:txtfmt_re_any_stok_atom =
				\(clr ? b:txtfmt_re_clr_stok_atom : '')
				\.nr2char(b:txtfmt_fmt_first_tok + 1).'-'.nr2char(b:txtfmt_fmt_last_tok)
				\.(bgc ? b:txtfmt_re_bgc_stok_atom : '')
	let b:txtfmt_re_any_etok_atom =
				\(clr ? b:txtfmt_re_clr_etok_atom : '')
				\.b:txtfmt_re_fmt_etok_atom
				\.(bgc ? b:txtfmt_re_bgc_etok_atom : '')

	if b:txtfmt_cfg_escape == 'bslash'
		" The following pattern is a zero-width look-behind assertion, which
		" matches only at a non-backslash-escaped position.
		let noesc = '\%(\%(^\|[^\\]\)\%(\\\\\)*\\\)\@<!'
		" Make this persistent, as it's used elsewhere...
		let b:re_no_bslash_esc = noesc
		" clr
		if clr
			" Active clr only
			let b:txtfmt_re_clr_tok = noesc.'['.b:txtfmt_re_clr_tok_atom.']'
			let b:txtfmt_re_clr_stok = noesc.'['.b:txtfmt_re_clr_stok_atom.']'
			let b:txtfmt_re_clr_etok = noesc.b:txtfmt_re_clr_etok_atom
			let b:txtfmt_re_clr_ntok = '\%('.b:txtfmt_re_clr_tok.'\)\@!.'
			" Active and inactive clr
			let b:txtfmt_re_CLR_tok = noesc.'['.b:txtfmt_re_CLR_tok_atom.']'
			let b:txtfmt_re_CLR_stok = noesc.'['.b:txtfmt_re_CLR_stok_atom.']'
			let b:txtfmt_re_CLR_etok = noesc.b:txtfmt_re_CLR_etok_atom
			let b:txtfmt_re_CLR_ntok = '\%('.b:txtfmt_re_CLR_tok.'\)\@!.'
		endif
		" bgc
		if bgc
			" Active bgc only
			let b:txtfmt_re_bgc_tok = noesc.'['.b:txtfmt_re_bgc_tok_atom.']'
			let b:txtfmt_re_bgc_stok = noesc.'['.b:txtfmt_re_bgc_stok_atom.']'
			let b:txtfmt_re_bgc_etok = noesc.b:txtfmt_re_bgc_etok_atom
			let b:txtfmt_re_bgc_ntok = '\%('.b:txtfmt_re_bgc_tok.'\)\@!.'
			" Active and inactive bgc
			let b:txtfmt_re_BGC_tok = noesc.'['.b:txtfmt_re_BGC_tok_atom.']'
			let b:txtfmt_re_BGC_stok = noesc.'['.b:txtfmt_re_BGC_stok_atom.']'
			let b:txtfmt_re_BGC_etok = noesc.b:txtfmt_re_BGC_etok_atom
			let b:txtfmt_re_BGC_ntok = '\%('.b:txtfmt_re_BGC_tok.'\)\@!.'
		endif
		" fmt
		let b:txtfmt_re_fmt_tok = noesc.'['.b:txtfmt_re_fmt_tok_atom.']'
		let b:txtfmt_re_fmt_stok = noesc.'['.b:txtfmt_re_fmt_stok_atom.']'
		let b:txtfmt_re_fmt_etok = noesc.b:txtfmt_re_fmt_etok_atom
		let b:txtfmt_re_fmt_ntok = '\%('.b:txtfmt_re_fmt_tok.'\)\@!.'
		" clr/bgc/fmt combined
		let b:txtfmt_re_any_tok = noesc.'['.b:txtfmt_re_any_tok_atom.']'
		let b:txtfmt_re_ANY_tok = noesc.'['.b:txtfmt_re_ANY_tok_atom.']'
		let b:txtfmt_re_any_stok = noesc.'['.b:txtfmt_re_any_stok_atom.']'
		let b:txtfmt_re_any_etok =
					\ noesc.'['
						\ . (clr ? b:txtfmt_re_clr_etok_atom : '')
						\ . (bgc ? b:txtfmt_re_bgc_etok_atom : '')
						\ . b:txtfmt_re_fmt_etok_atom
					\ . ']'
		let b:txtfmt_re_any_ntok = '\%('.b:txtfmt_re_any_tok.'\)\@!.'
	elseif b:txtfmt_cfg_escape == 'self'
		" The following pattern serves as the template for finding tokens that
		" are neither escaping nor escaped.
		let tmpl = '\%(\(placeholder\)\%(\1\)\@!\)\@=\%(\%(^\|\%(\1\)\@!.\)\%(\1\1\)*\1\)\@<!.'
		" Make this persistent, as it's used elsewhere...
		let b:re_no_self_esc = tmpl
		" clr
		if clr
			" Active clr only
			let b:txtfmt_re_clr_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_clr_tok_atom.']', '')
			let b:txtfmt_re_clr_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_clr_stok_atom.']', '')
			let b:txtfmt_re_clr_etok = substitute(tmpl, 'placeholder', b:txtfmt_re_clr_etok_atom, '')
			let b:txtfmt_re_clr_ntok = '\%('.b:txtfmt_re_clr_tok.'\)\@!.'
			" Active and inactive clr
			let b:txtfmt_re_CLR_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_CLR_tok_atom.']', '')
			let b:txtfmt_re_CLR_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_CLR_stok_atom.']', '')
			let b:txtfmt_re_CLR_etok = substitute(tmpl, 'placeholder', b:txtfmt_re_CLR_etok_atom, '')
			let b:txtfmt_re_CLR_ntok = '\%('.b:txtfmt_re_CLR_tok.'\)\@!.'
		endif
		" bgc
		if bgc
			" Active bgc only
			let b:txtfmt_re_bgc_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_bgc_tok_atom.']', '')
			let b:txtfmt_re_bgc_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_bgc_stok_atom.']', '')
			let b:txtfmt_re_bgc_etok = substitute(tmpl, 'placeholder', b:txtfmt_re_bgc_etok_atom, '')
			let b:txtfmt_re_bgc_ntok = '\%('.b:txtfmt_re_bgc_tok.'\)\@!.'
			" Active and inactive bgc
			let b:txtfmt_re_BGC_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_BGC_tok_atom.']', '')
			let b:txtfmt_re_BGC_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_BGC_stok_atom.']', '')
			let b:txtfmt_re_BGC_etok = substitute(tmpl, 'placeholder', b:txtfmt_re_BGC_etok_atom, '')
			let b:txtfmt_re_BGC_ntok = '\%('.b:txtfmt_re_BGC_tok.'\)\@!.'
		endif
		" fmt
		let b:txtfmt_re_fmt_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_fmt_tok_atom.']', '')
		let b:txtfmt_re_fmt_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_fmt_stok_atom.']', '')
		let b:txtfmt_re_fmt_etok = substitute(tmpl, 'placeholder', b:txtfmt_re_fmt_etok_atom, '')
		let b:txtfmt_re_fmt_ntok = '\%('.b:txtfmt_re_fmt_tok.'\)\@!.'
		" clr/bgc/fmt combined
		let b:txtfmt_re_any_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_any_tok_atom.']', '')
		let b:txtfmt_re_ANY_tok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_ANY_tok_atom.']', '')
		let b:txtfmt_re_any_stok = substitute(tmpl, 'placeholder', '['.b:txtfmt_re_any_stok_atom.']', '')
		let b:txtfmt_re_any_etok = substitute(tmpl, 'placeholder',
					\'['
					\.(clr ? nr2char(b:txtfmt_clr_first_tok) : '')
					\.(bgc ? nr2char(b:txtfmt_bgc_first_tok) : '')
					\.nr2char(b:txtfmt_fmt_first_tok)
					\.']', '')
		let b:txtfmt_re_any_ntok = '\%('.b:txtfmt_re_any_tok.'\)\@!.'
	else
		" No escaping of tokens
		" clr
		if clr
			" Active clr only
			let b:txtfmt_re_clr_tok = '['.b:txtfmt_re_clr_tok_atom.']'
			let b:txtfmt_re_clr_stok = '['.b:txtfmt_re_clr_stok_atom.']'
			let b:txtfmt_re_clr_etok = b:txtfmt_re_clr_etok_atom
			let b:txtfmt_re_clr_ntok = '[^'.b:txtfmt_re_clr_tok_atom.']'
			" Active and inactive clr
			let b:txtfmt_re_CLR_tok = '['.b:txtfmt_re_CLR_tok_atom.']'
			let b:txtfmt_re_CLR_stok = '['.b:txtfmt_re_CLR_stok_atom.']'
			let b:txtfmt_re_CLR_etok = b:txtfmt_re_CLR_etok_atom
			let b:txtfmt_re_CLR_ntok = '[^'.b:txtfmt_re_CLR_tok_atom.']'
		endif
		" bgc
		if bgc
			" Active bgc only
			let b:txtfmt_re_bgc_tok = '['.b:txtfmt_re_bgc_tok_atom.']'
			let b:txtfmt_re_bgc_stok = '['.b:txtfmt_re_bgc_stok_atom.']'
			let b:txtfmt_re_bgc_etok = b:txtfmt_re_bgc_etok_atom
			let b:txtfmt_re_bgc_ntok = '[^'.b:txtfmt_re_bgc_tok_atom.']'
			" Active and inactive bgc
			let b:txtfmt_re_BGC_tok = '['.b:txtfmt_re_BGC_tok_atom.']'
			let b:txtfmt_re_BGC_stok = '['.b:txtfmt_re_BGC_stok_atom.']'
			let b:txtfmt_re_BGC_etok = b:txtfmt_re_BGC_etok_atom
			let b:txtfmt_re_BGC_ntok = '[^'.b:txtfmt_re_BGC_tok_atom.']'
		endif
		" fmt
		let b:txtfmt_re_fmt_tok = '['.b:txtfmt_re_fmt_tok_atom.']'
		let b:txtfmt_re_fmt_stok = '['.b:txtfmt_re_fmt_stok_atom.']'
		let b:txtfmt_re_fmt_etok = b:txtfmt_re_fmt_etok_atom
		let b:txtfmt_re_fmt_ntok = '[^'.b:txtfmt_re_fmt_tok_atom.']'
		" clr/bgc/fmt combined
		let b:txtfmt_re_any_tok = '['.b:txtfmt_re_any_tok_atom.']'
		let b:txtfmt_re_ANY_tok = '['.b:txtfmt_re_ANY_tok_atom.']'
		let b:txtfmt_re_any_stok = '['.b:txtfmt_re_any_stok_atom.']'
		let b:txtfmt_re_any_etok =
					\'['
					\.(clr ? b:txtfmt_re_clr_etok_atom : '')
					\.(bgc ? b:txtfmt_re_bgc_etok_atom : '')
					\.b:txtfmt_re_fmt_etok_atom
					\.']'
		let b:txtfmt_re_any_ntok =
					\'[^'
					\.(clr ? b:txtfmt_re_clr_tok_atom : '')
					\.(bgc ? b:txtfmt_re_bgc_tok_atom : '')
					\.b:txtfmt_re_fmt_tok_atom
					\.']'
	endif
endfu
" >>>
" Function: s:Do_config_common() <<<
" Purpose: Set script local variables, taking into account whether user has
" overriden via txtfmt globals.
fu! s:Do_config_common()
	" unlet any buffer-specific options that may be set by txtfmt modeline <<<
	unlet! b:txtfmt_cfg_tokrange
				\ b:txtfmt_cfg_sync b:txtfmt_cfg_escape
				\ b:txtfmt_cfg_pack b:txtfmt_cfg_nested
				\ b:txtfmt_cfg_numfgcolors b:txtfmt_cfg_numbgcolors
				\ b:txtfmt_cfg_fgcolormask b:txtfmt_cfg_bgcolormask
				\ b:txtfmt_cfg_undercurlpref b:txtfmt_cfg_conceal
				\ b:txtfmt_cfg_concealcursor b:txtfmt_cfg_concealcursor_invalid
	" >>>
	" Attempt to process modeline <<<
	let ml_status = s:Do_txtfmt_modeline()
	" >>>
	" 'escape' option <<<
	if !exists('b:txtfmt_cfg_escape') || strlen(b:txtfmt_cfg_escape) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		unlet! l:bad_set_by
		if exists('b:txtfmt_cfg_escape') && strlen(b:txtfmt_cfg_escape) == 0
			" Bad modeline set
			let l:bad_set_by = 'm'
		elseif exists('b:txtfmtEscape')
			" User overrode buf-local option
			if s:Escape_is_valid(b:txtfmtEscape)
				let b:txtfmt_cfg_escape = b:txtfmtEscape
			else
				let l:bad_set_by = 'b'
			endif
		elseif exists('g:txtfmtEscape')
			" User overrode global option
			if s:Escape_is_valid(g:txtfmtEscape)
				let b:txtfmt_cfg_escape = g:txtfmtEscape
			else
				let l:bad_set_by = 'g'
			endif
		endif
		" Warn user if invalid user-setting is about to be overridden
		if exists('l:bad_set_by')
			" Note: Display the offending option value for buf-local or global
			" option, but not for modeline, since modeline processing has
			" already reported the error.
			echoerr "Warning: Ignoring invalid ".(
				\ l:bad_set_by == 'm' ? "modeline" :
				\ l:bad_set_by == 'b' ? "buf-local" :
				\ "global") . " value for txtfmt `escape' option" . (
				\ l:bad_set_by == 'm' ? '' :
				\ l:bad_set_by == 'b' ? (': ' . b:txtfmtEscape) :
				\ (': ' . g:txtfmtEscape))
		endif
		if !exists('b:txtfmt_cfg_escape') || strlen(b:txtfmt_cfg_escape) == 0
			" Set to default
			let b:txtfmt_cfg_escape = 'none'
		endif
	endif
	" >>>
	" 'pack' option <<<
	if !exists('b:txtfmt_cfg_pack') || strlen(b:txtfmt_cfg_pack) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		if exists('b:txtfmt_cfg_pack') && strlen(b:txtfmt_cfg_pack) == 0
			" Bad modeline set. Warn user that we're about to override. Note
			" that modeline processing has already reported the specific
			" error.
			echoerr "Warning: Ignoring invalid modeline value for txtfmt `pack' option"
		elseif exists('b:txtfmtPack')
			" User overrode buf-local option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_pack = b:txtfmtPack
		elseif exists('g:txtfmtPack')
			" User overrode global option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_pack = g:txtfmtPack
		endif
		if !exists('b:txtfmt_cfg_pack') || strlen(b:txtfmt_cfg_pack) == 0
			" Set to default (on)
			let b:txtfmt_cfg_pack = 1
		endif
	endif
	" >>>
	" 'undercurl' option <<<
	if !exists('b:txtfmt_cfg_undercurlpref') || strlen(b:txtfmt_cfg_undercurlpref) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		if exists('b:txtfmt_cfg_undercurlpref') && strlen(b:txtfmt_cfg_undercurlpref) == 0
			" Bad modeline set. Warn user that we're about to override. Note
			" that modeline processing has already reported the specific
			" error.
			echoerr "Warning: Ignoring invalid modeline value for txtfmt `undercurl' option"
		elseif exists('b:txtfmtUndercurl')
			" User overrode buf-local option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_undercurlpref = b:txtfmtUndercurl
		elseif exists('g:txtfmtUndercurl')
			" User overrode global option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_undercurlpref = g:txtfmtUndercurl
		endif
		if !exists('b:txtfmt_cfg_undercurlpref') || strlen(b:txtfmt_cfg_undercurlpref) == 0
			" Set to default (on)
			" Note: This is 'preference' only; if Vim version doesn't support
			" undercurl, we won't attempt to enable.
			let b:txtfmt_cfg_undercurlpref = 1
		endif
	endif
	" >>>
	" 'nested' option <<<
	if !exists('b:txtfmt_cfg_nested') || strlen(b:txtfmt_cfg_nested) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		if exists('b:txtfmt_cfg_nested') && strlen(b:txtfmt_cfg_nested) == 0
			" Bad modeline set. Warn user that we're about to override. Note
			" that modeline processing has already reported the specific
			" error.
			echoerr "Warning: Ignoring invalid modeline value for txtfmt `nested' option"
		elseif exists('b:txtfmtNested')
			" User overrode buf-local option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_nested = b:txtfmtNested
		elseif exists('g:txtfmtNested')
			" User overrode global option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_nested = g:txtfmtNested
		endif
		if !exists('b:txtfmt_cfg_nested') || strlen(b:txtfmt_cfg_nested) == 0
			" Set to default (on)
			let b:txtfmt_cfg_nested = 1
		endif
	endif
	" >>>
	" 'conceal' option <<<
	if !exists('b:txtfmt_cfg_conceal') || strlen(b:txtfmt_cfg_conceal) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		if exists('b:txtfmt_cfg_conceal')
			if strlen(b:txtfmt_cfg_conceal) == 0
				" Bad modeline set. Warn user that we're about to override. Note
				" that modeline processing has already reported the specific
				" error.
				echoerr "Warning: Ignoring invalid modeline value for txtfmt `conceal' option"
			elseif b:txtfmt_cfg_conceal && !has('conceal')
				" Modeline enables 'conceal' but the feature isn't supported
				" by Vim. Silently override the request.
				let b:txtfmt_cfg_conceal = 0
			endif
		elseif exists('b:txtfmtConceal')
			" User overrode buf-local option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_conceal = has('conceal') && b:txtfmtConceal
		elseif exists('g:txtfmtConceal')
			" User overrode global option
			" Note: Invalid setting impossible for boolean
			let b:txtfmt_cfg_conceal = has('conceal') && g:txtfmtConceal
		endif
		if !exists('b:txtfmt_cfg_conceal') || strlen(b:txtfmt_cfg_conceal) == 0
			" Enable if support for 'conceal' feature is compiled into Vim.
			" Note: This is a slightly non-backwards-compatible change with
			" respect to Txtfmt version 2.3. See help for explanation.
			let b:txtfmt_cfg_conceal = has('conceal')
		endif
	endif
	" >>>
	" 'concealcursor' option (dependent upon 'conceal') <<<
	" Note: The value of this option will be ignored if 'conceal' is off (in
	" which case, it might be safest to unset it).
	if b:txtfmt_cfg_conceal
		if !exists('b:txtfmt_cfg_concealcursor') || exists('b:txtfmt_cfg_concealcursor_invalid')
			" Either option wasn't set within modeline, or it was set to invalid
			" value
			unlet! l:bad_set_by
			if exists('b:txtfmt_cfg_concealcursor_invalid')
				" Bad modeline set
				let l:bad_set_by = 'm'
			elseif exists('b:txtfmtConcealcursor')
				" User overrode buf-local option
				if s:Concealcursor_is_valid(b:txtfmtConcealcursor)
					let b:txtfmt_cfg_concealcursor = b:txtfmtConcealcursor
				else
					let l:bad_set_by = 'b'
				endif
			elseif exists('g:txtfmtConcealcursor')
				" User overrode global option
				if s:Concealcursor_is_valid(g:txtfmtConcealcursor)
					let b:txtfmt_cfg_concealcursor = g:txtfmtConcealcursor
				else
					let l:bad_set_by = 'g'
				endif
			endif
			" Warn user if invalid user-setting is about to be overridden
			if exists('l:bad_set_by')
				" Note: Display the offending option value for buf-local or global
				" option, but not for modeline, since modeline processing has
				" already reported the error.
				echoerr "Warning: Ignoring invalid ".(
					\ l:bad_set_by == 'm' ? "modeline" :
					\ l:bad_set_by == 'b' ? "buf-local" :
					\ "global") . " value for txtfmt `concealcursor' option" . (
					\ l:bad_set_by == 'm' ? '' :
					\ l:bad_set_by == 'b' ? (': ' . b:txtfmtConcealcursor) :
					\ (': ' . g:txtfmtConcealcursor))
			endif
			if !exists('b:txtfmt_cfg_concealcursor') || exists('b:txtfmt_cfg_concealcursor_invalid')
				" By default, conceal tokens always, even in cursor line
				let b:txtfmt_cfg_concealcursor = 'nvic'
			endif
			" At this point, b:txtfmt_cfg_concealcursor_invalid has served its
			" purpose, and although it's unlet at the head of this function,
			" I'd rather not leave an 'invalid' var in existence.
			unlet! b:txtfmt_cfg_concealcursor_invalid
		endif
	else
		" This option is N/A when 'conceal' is off
		unlet! b:txtfmt_cfg_concealcursor
	endif
	" >>>
	" 'tokrange' option <<<
	" Note: 'starttok' and 'formats' are distinct options internally, but may
	" be set only as a unit by the plugin user. Even if tokrange was set
	" within modeline, there is work yet to be done.
	call s:Set_tokrange()
	" >>>
	" 'fgcolormask' option <<<
	if !exists('b:txtfmt_cfg_fgcolormask') || strlen(b:txtfmt_cfg_fgcolormask) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		unlet! l:bad_set_by
		if exists('b:txtfmt_cfg_fgcolormask') && strlen(b:txtfmt_cfg_fgcolormask) == 0
			" Bad modeline set
			let l:bad_set_by = 'm'
		elseif exists('b:txtfmtFgcolormask')
			" User overrode buf-local option
			if s:Clrmask_is_valid(b:txtfmtFgcolormask)
				let b:txtfmt_cfg_fgcolormask = b:txtfmtFgcolormask
			else
				let l:bad_set_by = 'b'
			endif
		elseif exists('g:txtfmtFgcolormask')
			" User overrode global option
			if s:Clrmask_is_valid(g:txtfmtFgcolormask)
				let b:txtfmt_cfg_fgcolormask = g:txtfmtFgcolormask
			else
				let l:bad_set_by = 'g'
			endif
		endif
		" Warn user if invalid user-setting is about to be overridden
		if exists('l:bad_set_by')
			" Note: Display the offending option value for buf-local or global
			" option, but not for modeline, since modeline processing has
			" already reported the error.
			echoerr "Warning: Ignoring invalid ".(
				\ l:bad_set_by == 'm' ? "modeline" :
				\ l:bad_set_by == 'b' ? "buf-local" :
				\ "global") . " value for txtfmt `fgcolormask' option" . (
				\ l:bad_set_by == 'm' ? '' :
				\ l:bad_set_by == 'b' ? (': ' . b:txtfmtFgcolormask) :
				\ (': ' . g:txtfmtFgcolormask))
		endif
		if !exists('b:txtfmt_cfg_fgcolormask') || strlen(b:txtfmt_cfg_fgcolormask) == 0
			" Set to default - all foreground colors active (for backward
			" compatibility)
			" TODO: Don't hardcode
			let b:txtfmt_cfg_fgcolormask = '11111111'
		endif
	endif
	" >>>
	" 'bgcolormask' option <<<
	if !exists('b:txtfmt_cfg_bgcolormask') || strlen(b:txtfmt_cfg_bgcolormask) == 0
		" Either option wasn't set within modeline, or it was set to invalid
		" value
		unlet! l:bad_set_by
		if exists('b:txtfmt_cfg_bgcolormask') && strlen(b:txtfmt_cfg_bgcolormask) == 0
			" Bad modeline set
			let l:bad_set_by = 'm'
		elseif exists('b:txtfmtBgcolormask')
			" User overrode buf-local option
			if s:Clrmask_is_valid(b:txtfmtBgcolormask)
				let b:txtfmt_cfg_bgcolormask = b:txtfmtBgcolormask
			else
				let l:bad_set_by = 'b'
			endif
		elseif exists('g:txtfmtBgcolormask')
			" User overrode global option
			if s:Clrmask_is_valid(g:txtfmtBgcolormask)
				let b:txtfmt_cfg_bgcolormask = g:txtfmtBgcolormask
			else
				let l:bad_set_by = 'g'
			endif
		endif
		" Warn user if invalid user-setting is about to be overridden
		if exists('l:bad_set_by')
			" Note: Display the offending option value for buf-local or global
			" option, but not for modeline, since modeline processing has
			" already reported the error.
			echoerr "Warning: Ignoring invalid ".(
				\ l:bad_set_by == 'm' ? "modeline" :
				\ l:bad_set_by == 'b' ? "buf-local" :
				\ "global") . " value for txtfmt `bgcolormask' option" . (
				\ l:bad_set_by == 'm' ? '' :
				\ l:bad_set_by == 'b' ? (': ' . b:txtfmtBgcolormask) :
				\ (': ' . g:txtfmtBgcolormask))
		endif
		if !exists('b:txtfmt_cfg_bgcolormask') || strlen(b:txtfmt_cfg_bgcolormask) == 0
			" Set to default of red, green and blue if background colors are
			" active; otherwise, disable all colors.
			" TODO_BG: Decide whether it makes sense to unlet the variable
			" completely.
			" TODO_BG: b:txtfmt_cfg_bgcolor is probably not set yet!!!! This
			" needs to be moved till after Set_tokrange
			if b:txtfmt_cfg_bgcolor
				" TODO: Don't hardcode
				let b:txtfmt_cfg_bgcolormask = '01101000'
			else
				" No background color supported
				let b:txtfmt_cfg_bgcolormask = '00000000'
			endif
		endif
	endif
	" Force mask to all zeroes if background colors are disabled.
	" Assumption: Set_tokrange has already run; thus, b:txtfmt_cfg_bgcolor has
	" been set.
	if !b:txtfmt_cfg_bgcolor
		let b:txtfmt_cfg_bgcolormask = '00000000'
	endif
	" >>>
	" 'sync' option <<<
	" Note: 'syncmethod' and 'synclines' are distinct options internally, but
	" may be set only as a unit by the plugin user. Even if sync was set
	" within modeline, there is work yet to be done.
	call s:Set_syncing()
	" >>>
	" Define various buffer-specific variables now that fmt/clr ranges are fixed.
	" TODO: Perhaps combine the following 2 functions in some way...
	call s:Define_fmtclr_vars()
	" Define fmt/clr regexes - used in both syntax and ftplugin <<<
	call s:Define_fmtclr_regexes()
	" >>>
	" Process color options <<<
	call s:Process_color_options()
	" >>>
endfu
" >>>
call s:Do_config_common()
" Define buffer-local constants <<<
" For convenience, associate format indices with their respective
" '[u][b][i][s][r][c]' string, in fiducial form. Note that fiducial form may
" be used for display, but is also a valid (but not the only) fmt spec.
let b:ubisrc_fmt0  = '-'
let b:ubisrc_fmt1  = 'u'
let b:ubisrc_fmt2  = 'b'
let b:ubisrc_fmt3  = 'bu'
let b:ubisrc_fmt4  = 'i'
let b:ubisrc_fmt5  = 'iu'
let b:ubisrc_fmt6  = 'ib'
let b:ubisrc_fmt7  = 'ibu'
let b:ubisrc_fmt8  = 's'
let b:ubisrc_fmt9  = 'su'
let b:ubisrc_fmt10 = 'sb'
let b:ubisrc_fmt11 = 'sbu'
let b:ubisrc_fmt12 = 'si'
let b:ubisrc_fmt13 = 'siu'
let b:ubisrc_fmt14 = 'sib'
let b:ubisrc_fmt15 = 'sibu'
let b:ubisrc_fmt16 = 'r'
let b:ubisrc_fmt17 = 'ru'
let b:ubisrc_fmt18 = 'rb'
let b:ubisrc_fmt19 = 'rbu'
let b:ubisrc_fmt20 = 'ri'
let b:ubisrc_fmt21 = 'riu'
let b:ubisrc_fmt22 = 'rib'
let b:ubisrc_fmt23 = 'ribu'
let b:ubisrc_fmt24 = 'rs'
let b:ubisrc_fmt25 = 'rsu'
let b:ubisrc_fmt26 = 'rsb'
let b:ubisrc_fmt27 = 'rsbu'
let b:ubisrc_fmt28 = 'rsi'
let b:ubisrc_fmt29 = 'rsiu'
let b:ubisrc_fmt30 = 'rsib'
let b:ubisrc_fmt31 = 'rsibu'
let b:ubisrc_fmt32 = 'c'
let b:ubisrc_fmt33 = 'cu'
let b:ubisrc_fmt34 = 'cb'
let b:ubisrc_fmt35 = 'cbu'
let b:ubisrc_fmt36 = 'ci'
let b:ubisrc_fmt37 = 'ciu'
let b:ubisrc_fmt38 = 'cib'
let b:ubisrc_fmt39 = 'cibu'
let b:ubisrc_fmt40 = 'cs'
let b:ubisrc_fmt41 = 'csu'
let b:ubisrc_fmt42 = 'csb'
let b:ubisrc_fmt43 = 'csbu'
let b:ubisrc_fmt44 = 'csi'
let b:ubisrc_fmt45 = 'csiu'
let b:ubisrc_fmt46 = 'csib'
let b:ubisrc_fmt47 = 'csibu'
let b:ubisrc_fmt48 = 'cr'
let b:ubisrc_fmt49 = 'cru'
let b:ubisrc_fmt50 = 'crb'
let b:ubisrc_fmt51 = 'crbu'
let b:ubisrc_fmt52 = 'cri'
let b:ubisrc_fmt53 = 'criu'
let b:ubisrc_fmt54 = 'crib'
let b:ubisrc_fmt55 = 'cribu'
let b:ubisrc_fmt56 = 'crs'
let b:ubisrc_fmt57 = 'crsu'
let b:ubisrc_fmt58 = 'crsb'
let b:ubisrc_fmt59 = 'crsbu'
let b:ubisrc_fmt60 = 'crsi'
let b:ubisrc_fmt61 = 'crsiu'
let b:ubisrc_fmt62 = 'crsib'
let b:ubisrc_fmt63 = 'crsibu'
" >>>
else " if exists('b:txtfmt_do_common_config')
" Function: s:Txtfmt_refresh() <<<
" Purpose: Invoked by buffer-local command Refresh when user wishes to
" reload txtfmt plugins safely for the current buffer; e.g., after changing
" option settings.
" Important Note: This function must be within the else of an if
" exists('b:txtfmt_do_common_config'); otherwise, we will get an error when this
" function causes the plugins to be re-sourced, since the re-sourcing of this
" file will result in an attempt to redefine the function while it is running!
fu! s:Txtfmt_refresh()
	" Ensure that common configuration code will not be skipped next time
	unlet! b:txtfmt_did_common_config
	" Determine whether txtfmt ftplugin is loaded
	if exists('b:loaded_txtfmt')
		" b:loaded_txtfmt is set only within ftplugin/txtfmt.vim and unlet by
		" b:undo_ftplugin; hence, its existence indicates that txtfmt ftplugin
		" is currently loaded. Cache the filetype that was cached at load
		" time.
		let l:current_filetype = b:txtfmt_filetype
	endif
	" Determine whether txtfmt syntax plugin is loaded
	let v:errmsg = ''
	silent! syn sync match Tf_existence_test grouphere Tf_fmt_1 /\%^/
	if v:errmsg == ''
		" No error means txtfmt syntax plugin is loaded. Cache the syntax name
		" that was cached at load time.
		let l:current_syntax = b:txtfmt_syntax
	endif
	" Is there anything to refresh?
	if !exists('l:current_filetype') && !exists('l:current_syntax')
		echomsg "Warning: Useless call to Refresh: "
			\."no txtfmt plugins appear to be loaded."
		return
	endif
	" If here, there was a reason for the Txtfmt_refresh call. Cause ftplugin
	" and/or syntax plugin to be reloaded via FileType and Syntax sets, as
	" appropriate.
	if exists('l:current_syntax')
		" We're going to attempt to reload syntax plugin. Unload it now
		" (causing b:current_syntax to be unlet). If we set filetype below,
		" and b:current_syntax exists afterwards, we'll know syntax was loaded
		" via syntaxset autocmd linked to FileType event. Alternatively,
		" could simply unlet b:current_syntax here...
		set syntax=OFF
	endif
	if exists('l:current_filetype')
		" Set filetype to whatever it was before
		exe 'set filetype=' . l:current_filetype
	endif
	if exists('l:current_syntax')
		" Syntax may have been loaded already, but if not, we'll need to do it
		" manually...
		if exists('b:current_syntax')
			" Syntax was loaded as a result of the filetype set. Make sure it
			" appears to be the correct one.
			if b:current_syntax != l:current_syntax
				echomsg "Warning: Txtfmt attempted to restore syntax to `"
				\.l:current_syntax."'. Result was `".b:current_syntax."'"
				echomsg "I'm guessing you have loaded the txtfmt plugins "
				\."in a non-standard manner. See txtfmt help for more information."
			endif
		else
			" Syntax wasn't linked to filetype. Load the desired syntax manually.
			exe 'set syntax=' . l:current_syntax
		endif
	endif	
endfu
" >>>
endif " if exists('b:txtfmt_do_common_config')
" General-purpose utilities <<<
" Note: These utilities are defined globally in the plugin file so that they
" might be used by any of the Txtfmt script files.
" Naming Convention: All of these utilities should begin with 'TxtfmtUtil_'
" and should separate internal 'words' with underscore. Internal words should
" not be capitalized.
" Function: TxtfmtUtil_num_to_hex_str <<<
" Description: Take the input value and convert it to a hex string of the form
" 0xXXXX.
" Format Note: Output string will have '0x' prepended, but will omit leading
" zeroes.
fu! TxtfmtUtil_num_to_hex_str(num)
	" Get writable copy
	let num = a:num
	" Loop until the value has been completely processed
	let str = ''
	let abcdef = "ABCDEF"
	while num > 0
		let dig = num % 16
		" Convert the digit value to a hex digit and prepend to hex str
		if dig <= 9
			let str = dig . str
		else
			let str = strpart(abcdef, dig - 10, 1) . str
		endif
		let num = num / 16
	endwhile
	" Prepend '0x' to hex string built in loop
	" Note: If string is empty, it should be '0'
	return '0x' . (strlen(str) == 0 ? '0' : str)
endfu
" >>>
" >>>
" Function: s:MakeTestPage() <<<
" Purpose: Build a "test-page" in a scratch buffer, to show user how color
" and format regions will look with current definitions and on current
" terminal. (Useful to prevent user from having to insert all the color and
" format regions manually with text such as "Here's a little test...")
" How: Create a scratch buffer whose filetype is set to txtfmt. Add some
" explanation lines at the top, followed by one line for each active color, as
" follows:
" color<num> none i b bi u ui ub ubi ...
" Repeat for each active background color...
" Note: The function is script-local, as it is designed to be invoked from a
" command.
" IMPORTANT NOTE: Special care must be taken when defining this function, as
" it creates a buffer with 'ft' set to txtfmt, which causes the script to be
" re-sourced. This leads to E127 'Cannot redefine function' when fu[!] is
" encountered, since the function is in the process of executing.
if !exists('*s:MakeTestPage')
fu! s:MakeTestPage(...)
	if a:0 == 1
		" User provided optional modeline arguments. Before opening scratch
		" buffer, make sure the modeline constructed from the arguments has at
		" least the overall appearance of being valid. (Option name/value
		" validation is performed only after opening the test page buffer.)
		if !s:Is_txtfmt_modeline("\<Tab>txtfmt:".a:1)
			" Warn of invalid modeline and return without creating the test
			" buffer
			echoerr "Invalid arguments passed to :MakeTestPage command: `".a:1."'"
			return
		endif
	endif
	" Attempt to open the buffer (success not guaranteed)
	if !s:New_window(s:TESTPAGE_WINHEIGHT)
		" If E36, give helpful message about increasing size of current
		" window; otherwise, given generic message followed by raw Vim
		" error message.
		if s:err_str =~ '^E36:'
			echoerr "MakeTestPage(): Can't open test page. Increase size of current window and try again."
		else
			echoerr "MakeTestPage(): Error opening test page: " . s:err_str
		endif
		" Abort test page
		return
	endif
	set buftype=nofile
	set bufhidden=hide
	set noswapfile
	" The following setlocal is necessary to prevent E21 in the event that
	" 'nomodifiable' is set globally.
	setlocal modifiable
	" If user provided modeline, add it to top of file before setting filetype
	" to txtfmt...
	if a:0 == 1
		let modeline = a:1
		if modeline =~ '\S'
			call setline(1, "\<Tab>txtfmt:".modeline)
		endif
	elseif a:0 > 1
		" This should never happen, since this function is called from a
		" mapping.
		echoerr "Too many arguments passed to MakeTestPage."
			\." (Note that this function should not be called directly.)"
	endif
	set filetype=txtfmt
	" Set page formatting options
	" TODO - Decide whether the following are necessary anymore. (I'm
	" formatting things explicitly now...)
	set noai ts=4 sw=4 tw=78
	set nowrap
	" Cache some special tokens that will be used on this page
	let tok_fb = Txtfmt_GetTokStr('fb')
	let tok_fui = Txtfmt_GetTokStr('fui')
	let tok_fu = Txtfmt_GetTokStr('fu')
	let tok_fmt_end = nr2char(b:txtfmt_fmt_first_tok)
	let tok_clr_end = nr2char(b:txtfmt_clr_first_tok)
	" Important Note: Most of the following logic assumes that each token that
	" is hidden by a txtfmt concealment group will appear as a single
	" whitespace. If the 'conceal' patch is in effect, however, such tokens
	" will not appear at all. The problem is that the token width is sometimes
	" used to achieve the desired alignment. To facilitate keeping the
	" alignment constant, I declare a variable that resolves to a single
	" whitespace if and only if the conceal patch is in effect. This variable
	" will be appended to tokens that would affect alignment in the absence of
	" the conceal patch.
	" Note: The space could go before or after the token, but after is best in
	" the case of bg colors.
	let cncl_ws = b:txtfmt_cfg_conceal ? ' ' : ''
	call append(line('$'), tok_fb)
	call append(line('$'),
		\"************************")
	$center
	call append(line('$'),
		\"*** TXTFMT TEST PAGE ***")
	$center
	call append(line('$'),
		\"************************")
	$center
	call append(line('$'),
		\"=============================================================================")
	call append(line('$'),
		\"*** Overview ***")
	$center
	call append(line('$'), tok_fmt_end)
	call append(line('$'), "")
	call append(line('$'),
		\"The purpose of this page is to present an overview of the txtfmt highlighting")
	call append(line('$'),
		\"that results from the global txtfmt options and any txtfmt modeline settings")
	call append(line('$'),
		\"passed to the MakeTestPage command.")
	call append(line('$'), "")
	call append(line('$'),
		\"	:help txtfmt-MakeTestPage")
	call append(line('$'), "")
	call append(line('$'),
		\"The text on the page has been chosen to display all possible combinations of")
	call append(line('$'),
		\"color and format regions, and if applicable, to illustrate the escaping of")
	call append(line('$'),
		\"tokens and the nesting of txtfmt regions.")
	call append(line('$'), tok_fb)
	call append(line('$'),
		\"=============================================================================")
	call append(line('$'),
		\"*** Colors and Formats ***")
	$center
	call append(line('$'), tok_fui)
	" Possible TODO: Use b:txtfmt_cfg_tokrange so that number format specified
	" by user is respected.
	call append(line('$'),
		\'Configuration:'.tok_fb.cncl_ws
		\."tokrange =".tok_fmt_end.cncl_ws
		\.b:txtfmt_cfg_starttok_display.b:txtfmt_cfg_formats_display
		\)
	call append(line('$'), "")
	call append(line('$'),
		\"\<Tab>start token: ".b:txtfmt_cfg_starttok_display)
	call append(line('$'),
		\"\<Tab>background colors: ".(b:txtfmt_cfg_bgcolor
			\? "enabled (".b:txtfmt_cfg_numbgcolors." active)"
			\: "disabled"))
	call append(line('$'),
		\"\<Tab>".(b:txtfmt_cfg_longformats ? "'long'" : "'short'")." formats "
		\.(b:txtfmt_cfg_longformats
		\    ?
		\        (b:txtfmt_cfg_undercurl
		\        ? "with"
		\        : "without")
		\        ." undercurl"
		\    :
		\        ""
		\ ))
	call append(line('$'), '')
	" TODO_BG: Decide whether to attempt to be more discriminating: e.g., what
	" if bgcolor is enabled, but none are active? Same question for fgcolor?
	" Decision: I'm thinking there's no reason to do it. Typically, user won't
	" de-activate all colors, but if he does, perhaps we want him to scratch
	" his head a bit.
	if b:txtfmt_cfg_bgcolor
		call append(line('$'),
			\"Each line in the table below corresponds to a single permutation of foreground")
		call append(line('$'),
			\"and background colors. You may use the special global arrays g:txtfmtColor{}")
		call append(line('$'),
			\"and g:txtfmtBgcolor{} to change these colors.")
	else
		call append(line('$'),
			\"Each line in the table below corresponds to a single foreground color. You may")
		call append(line('$'),
			\"use the special global array g:txtfmtColor{} to change these colors.")
	endif
	call append(line('$'), '')
	call append(line('$'),
		\'    :help txtfmt-defining-colors')
	call append(line('$'), '')
	call append(line('$'),
		\"The ".b:txtfmt_num_formats." permutations of the format attributes ")
	call append(line('$'),
		\'(u=underline, b=bold, i=italic'
		\.(b:txtfmt_cfg_longformats
		\     ? ', s=standout, r=reverse'
		\       .b:txtfmt_cfg_undercurl
		\           ? ', c=undercurl'
		\           : ''
		\     : ''
		\ ).')')
	call append(line('$'), "are shown on each color line for completeness.")
	call append(line('$'), tok_fb)
	call append(line('$'),
		\"IMPORTANT NOTE:".tok_fmt_end."Txtfmt chooses a default range for clr/fmt tokens, which works")
	call append(line('$'),
		\"well on most terminals; however, this range may not be suitable for all")
	call append(line('$'),
		\"terminals. In particular, Vim cannot highlight those characters displayed by")
	call append(line('$'),
		\"the terminal as special 2-character sequences (e.g., ^M, ^B, etc...). Although")
	call append(line('$'),
		\"coloring and formatting of text will work when these characters are used as")
	call append(line('$'),
		\"tokens, their use is discouraged, because txtfmt is unable to conceal them. If")
	call append(line('$'),
		\"any such control sequences are visible in the sample text below, you may wish")
	call append(line('$'),
		\"to try a different range, either by setting global txtfmt option")
	call append(line('$'),
		\"g:txtfmtTokrange to a different value, or by including a different definition")
	call append(line('$'),
		\"in a txtfmt modeline string passed to the MakeTestPage command. Either way, you")
	call append(line('$'),
		\"will need to invoke MakeTestPage again to see whether the changed settings are")
	call append(line('$'),
		\"better.")
	call append(line('$'), "")
	call append(line('$'),
		\"    :help txtfmt-choosing-token-range")
	call append(line('$'), '')
	call append(line('$'), tok_fb)
	call append(line('$'),
		\'--color/format table--')
	call append(line('$'), tok_fmt_end)

	" Determine line on which to start the fmt/clr table
	let iLine = line('.')
	" Before looping over bgc, fgc and fmt, determine the length of the list
	" of format specs (i.e., the number of characters, including start fmt
	" specs, from the hyphen to the end of the line).
	" Assumption: Each format token will take up a single character width. (If
	" conceal patch is in effect, it will be a literal space.)
	" Note: We don't include either the 'no format' token at the end of the
	" line or the following space (used for table framing) in the count, as
	" these characters are beyond the edge of the table proper, and we want
	" them to extend beyond the end of the underscores.
	let post_hyphen_width = 1 " hyphen representing 'no fmt'
	let iFmt = 1 " start just after 'no format' token
	while iFmt < b:txtfmt_num_formats
		" Accumulate width of space and fmt spec
		let post_hyphen_width = post_hyphen_width + 1 + strlen(b:ubisrc_fmt{iFmt})
		let iFmt = iFmt + 1
	endwhile
	" Define width of lines up to the hyphen, *NOT* including potentially
	" multibyte token chars that appear at the beginning of the line. A fixed
	" number of columns will be reserved for such tokens.
	" Note: This width is chosen with the string 'no bg color' in mind
	let pre_hyphen_width = 16
	" Generate a string of underscores that spans the table (but not the
	" framing whitespace/tokens at left and right edges)
	let underscores = s:Repeat('_', pre_hyphen_width + post_hyphen_width)
	" Put the text into the buffer
	" Outer loop is over background colors
	" Note: piBgc in the loop below is a 1-based index into
	" b:txtfmt_cfg_bgcolor{}, the array of active color indices. This array
	" stores the actual color index corresponding to the piBgc'th active
	" color; i.e., it stores the indices that are used for the b:txtfmt_bgc{}
	" array. Both arrays are 1-based. Index 0 represents the default (no)
	" color token in b:txtfmt_bgc{}.
	" Note: Even if bgc is disabled, we'll iterate once for default background
	let piBgc = 0
	while piBgc <= (b:txtfmt_cfg_bgcolor ? b:txtfmt_cfg_numbgcolors : 0)
		" Get the actual color index via one level of indirection
		let iBgc = piBgc == 0 ? 0 : b:txtfmt_cfg_bgcolor{piBgc}
		" Don't output the bg color title if bgcolor is disabled
		if b:txtfmt_cfg_bgcolor
			" Put a line consisting entirely of underscores before the bg
			" color title line
			" Note: If this is not the default bg color, a bg token and
			" possibly a default fg token will need to be prepended.
			if iBgc == 0
				" Default bg color
				let s = '  '
			else
				" Non-default bg color
				let s = nr2char(b:txtfmt_bgc_first_tok + iBgc).cncl_ws
				if b:txtfmt_cfg_numfgcolors
					" We're currently inside a fg clr region, but bg color
					" title line should be default fg color, so end the fg
					" color
					let s = s.nr2char(b:txtfmt_clr_first_tok).cncl_ws
				else
					" No fg clr region to end, but need space for alignment
					let s = s.' '
				endif
			endif
			" Now append the underscores and a 2-space end of line pad
			let s = s . underscores . '  '
			call append(line('$'), s)
			" Insert a description of the current bg color
			if iBgc == 0
				let s = "  no bg color"
			else
				let s = "  Bg color ".iBgc
			endif
			" Append spaces such that background coloration is as wide as it is on
			" subsequent lines.
			" Note: The hardcoded 4 is for the beginning and end of line framing spaces
			" Note: s cannot contain multibyte chars at this point, so the
			" strlen() is safe.
			let s = s . s:Repeat(' ', pre_hyphen_width + post_hyphen_width + 4 - strlen(s))
			call append(line('$'), s)
			" Put a line consisting entirely of underscores after the bg color
			" title line
			call append(line('$'), '  ' . underscores . '  ')
		endif
		" Note: See notes on piBgc and iBgc above for description of piClr and
		" iClr.
		let piClr = 0
		while piClr <= b:txtfmt_cfg_numfgcolors
			" Get the actual color index via one level of indirection
			let iClr = piClr == 0 ? 0 : b:txtfmt_cfg_fgcolor{piClr}
			" Build the string for this line, taking care to ensure there is a
			" margin of 2 space widths
			" Note: Need to keep beginning of line spaces/tokens separate
			" until after the strlen(), since strlen counts characters rather
			" than bytes.
			if iClr == 0
				let ldr = '  '
				let s = "no fg color"
			else
				" Insert the non-default fg clr token, preceded by a space in
				" the column dedicated to bg clr tokens
				let ldr = ' '.nr2char(b:txtfmt_clr_first_tok + iClr).cncl_ws
				let s = 'Fg color '.iClr
			endif
			" Pad with spaces till hyphen
			let s = ldr . s . s:Repeat(' ', pre_hyphen_width - strlen(s))
			" Loop over format attributes
			let iFmt = 0
			while iFmt < b:txtfmt_num_formats
				if iFmt == 0
					let s = s.'-'
				else
					" Conceal patch entails special handling to prevent the
					" space between the specifiers from being underlined or
					" undercurled.
					" Case 1: 'conceal'
					" <SPC> <fmt-tok> <fmt-spec> <no-fmt-tok>
					" Case 2: 'noconceal'
					" <fmt-tok> <fmt-spec>
					" Note: For the 'noconceal' case *only*, a single
					" <no-fmt-tok> goes outside loop.
					let s = s . cncl_ws
						\. nr2char(b:txtfmt_fmt_first_tok + iFmt)
						\. b:ubisrc_fmt{iFmt}
						\. (b:txtfmt_cfg_conceal ? nr2char(b:txtfmt_fmt_first_tok) : '')
				endif
				let iFmt = iFmt + 1
			endwhile
			" If necessary, add default fmt token to prevent formatting from
			" spilling onto next line, and add space(s) for margin
			" Case 1: 'conceal'
			" <SPC> <SPC>
			" Case 2: 'noconceal'
			" <no-fmt-tok> <SPC>
			let s = s . (b:txtfmt_cfg_conceal ? ' ' : nr2char(b:txtfmt_fmt_first_tok)) . ' '
			call append(line('$'), s)
			let piClr = piClr + 1
		endwhile
		let piBgc = piBgc + 1
	endwhile
	" Return to default background and foreground colors (as applicable)
	" TODO: If 'conceal', then this has been done already.
	call append(line('$'),
		\(b:txtfmt_cfg_bgcolor && b:txtfmt_cfg_numbgcolors > 0 ? nr2char(b:txtfmt_bgc_first_tok) : '')
		\.(b:txtfmt_cfg_numfgcolors > 0 ? nr2char(b:txtfmt_clr_first_tok) : ''))

	call append(line('$'), tok_fb)
	call append(line('$'),
		\"=============================================================================")
	call append(line('$'),
		\"*** Escaping txtfmt tokens ***")
	$center
	call append(line('$'), tok_fui)
	call append(line('$'),
		\'Configuration:'.tok_fb.cncl_ws."escape".tok_fmt_end.cncl_ws."= ".b:txtfmt_cfg_escape)
	call append(line('$'), "")
	call append(line('$'),
		\"    :help txtfmt-escape")
	" Now display text specific to the option setting
	if b:txtfmt_cfg_escape != 'none'
		call append(line('$'), tok_fb)
		call append(line('$'),
			\'--Escaping tokens outside a region--'.tok_fmt_end)
		call append(line('$'),
			\"The following shows that all tokens (other than the \"no fmt\" / \"no clr\" tokens)")
		call append(line('$'),
			\"may be escaped to prevent them from beginning a region:")
		" Escaped fg color tokens
		call append(line('$'), '')
		call append(line('$'), tok_fb.cncl_ws
			\.'*'.(b:txtfmt_cfg_bgcolor ? 'fg ' : '').'color tokens*'.tok_fmt_end)
		" Loop over all clr tokens, inserting an escaped version of each.
		let s = ''
		let piClr = 1
		while piClr <= b:txtfmt_cfg_numfgcolors
			let iClr = b:txtfmt_cfg_fgcolor{piClr}
			let tok = nr2char(b:txtfmt_clr_first_tok + iClr)
			let s = s.cncl_ws.(b:txtfmt_cfg_escape == 'self' ? tok : '\').tok
			let piClr = piClr + 1
		endwhile
		if s == ''
			" Indicate that no fg colors are active
			let s = ' --N/A--'
		endif
		call append(line('$'), s)
		" Escaped bg color tokens
		if b:txtfmt_cfg_bgcolor
			call append(line('$'), tok_fb.cncl_ws
				\.'*bg color tokens*'.tok_fmt_end)
			" Loop over all bgc tokens, inserting an escaped version of each.
			let s = ''
			let piBgc = 1
			while piBgc <= b:txtfmt_cfg_numbgcolors
				let iBgc = b:txtfmt_cfg_bgcolor{piBgc}
				let tok = nr2char(b:txtfmt_bgc_first_tok + iBgc)
				let s = s.cncl_ws.(b:txtfmt_cfg_escape == 'self' ? tok : '\').tok
				let piBgc = piBgc + 1
			endwhile
			if s == ''
				" Indicate that no bg colors are active
				let s = ' --N/A--'
			endif
			call append(line('$'), s)
		endif
		" Escaped format tokens
		call append(line('$'), tok_fb.cncl_ws
			\.'*format tokens*'.tok_fmt_end)
		" Loop over all fmt tokens, inserting an escaped version of each.
		let s = ''
		let iFmt = 1
		while iFmt < b:txtfmt_num_formats
			let tok = nr2char(b:txtfmt_fmt_first_tok + iFmt)
			let s = s.cncl_ws.(b:txtfmt_cfg_escape == 'self' ? tok : '\').tok
			let iFmt = iFmt + 1
		endwhile
		call append(line('$'), s)
		call append(line('$'), tok_fb)
		call append(line('$'),
			\'--Escaping tokens inside a region--'.tok_fui)
		call append(line('$'), '')
		call append(line('$'),
			\"Here's a little swatch of \"underline, italic\" text. On the line below are some")
		call append(line('$'),
			\"escaped tokens, which, in their unescaped form, would alter the region's")
		call append(line('$'),
			\"formatting:")
		call append(line('$'),
			\(b:txtfmt_cfg_escape == 'self' ? tok_fb : '\').tok_fb
			\.' (escaped bold token), '
			\.(b:txtfmt_cfg_escape == 'self' ? tok_fmt_end : '\').tok_fmt_end
			\.' (escaped "no fmt" token)')
		call append(line('$'),
			\"As you can see, the escaping characters are concealed, and the formatting is")
		call append(line('$'),
			\"unaffected by the escaped tokens.")
		call append(line('$'),
			\"Note: After you have viewed the rest of this page, you may wish to experiment")
		call append(line('$'),
			\"by removing the escape tokens to see how the formatting is affected.")
	else
		" Inform user that escaping is not configured
		call append(line('$'), '')
		call append(line('$'),
			\"Escaping of txtfmt tokens is currently disabled.")
	endif

	call append(line('$'), tok_fb)
	call append(line('$'),
		\"=============================================================================")
	call append(line('$'),
		\"*** Nesting txtfmt regions ***")
	$center
	call append(line('$'), tok_fui)
	call append(line('$'),
		\'Configuration:'.tok_fb.cncl_ws.(b:txtfmt_cfg_nested ? "nested" : "nonested").tok_fmt_end)
	call append(line('$'), "")
	call append(line('$'),
		\"    :help txtfmt-nesting")
	" Now display text specific to the option setting
	if b:txtfmt_cfg_nested
		call append(line('$'), '')
		call append(line('$'),
			\"/* Here's a sample comment (italicized), intended to illustrate the nesting of")
		call append(line('$'),
			\" * txtfmt regions within non-txtfmt regions.")
		call append(line('$'),
			\" *")
		call append(line('$'),
			\" * The following txtfmt token -->".tok_fu."<-- begins a nested \"underline\" region, which")
		call append(line('$'),
			\" * ends with the following \"no fmt\" token. -->".tok_fmt_end."<--")
		call append(line('$'),
			\" * As you can see, the comment resumes automatically after the nested region")
		call append(line('$'),
			\" * ends. */")
		call append(line('$'), "")
		call append(line('$'),
			\"Non-txtfmt regions may be divided into two categories: those with the")
		call append(line('$'),
			\"'keepend' attribute, and those without it. To demonstrate the effect of the")
		call append(line('$'),
			\"'keepend' attribute on nested txtfmt regions, I have defined two additional")
		call append(line('$'),
			\"regions, enclosed by curly braces and square brackets respectively. The curly")
		call append(line('$'),
			\"brace region does not have the 'keepend' attribute; the square bracket region")
		call append(line('$'),
			\"does. Both regions are highlighted in bold.")
		call append(line('$'),
			\"{ Once again, here's a".tok_fu.cncl_ws."nested \"underline\" txtfmt region, followed by a curly")
		call append(line('$'),
			\"brace. }")
		call append(line('$'),
			\"As you can see, the nested txtfmt region was *not* terminated by the")
		call append(line('$'),
			\"closing curly brace. In fact, the curly brace region was extended by the")
		call append(line('$'),
			\"txtfmt region. Notice how the following txtfmt \"no fmt\" token -->".tok_fmt_end."<--")
		call append(line('$'),
			\"permits the resumption of the curly brace region}, which is finally ended by")
		call append(line('$'),
			\"the unobscured closing curly brace.")
		call append(line('$'),
			\"[ Notice, by contrast, how both the".tok_fu.cncl_ws."nested \"underline\" txtfmt region and the")
		call append(line('$'),
			\"square bracket region itself are terminated by the following square bracket ]")
		call append(line('$'),
			\"because the square bracket region was defined with the 'keepend' attribute.")


		" Define comment, curly brace, and square brace regions...
		syn region Tf_example_comment start=+/\*+ end=+\*/+ keepend
		hi Tf_example_comment cterm=italic gui=italic
		syn region Tf_example_curly start=+{+ end=+}+
		hi Tf_example_curly cterm=bold gui=bold
		syn region Tf_example_square start=+\[+ end=+\]+ keepend
		hi Tf_example_square cterm=bold gui=bold
	else
		" Inform user that nesting is not configured
		call append(line('$'), "")
		call append(line('$'),
			\"Nesting of txtfmt regions is currently disabled.")
	endif

endfu
endif	" if !exists('*s:MakeTestPage')
" >>>
" Public-interface commands <<<
" TODO - Add this command to undo list - Should it redefine (com!)?
com! -nargs=? MakeTestPage call s:MakeTestPage(<f-args>)
" >>>
	" vim: sw=4 ts=4 foldmethod=marker foldmarker=<<<,>>> :