Multiple vim updates, work related and whatnot

git-svn-id: http://photonzero.com/dotfiles/trunk@23 23f722f6-122a-0410-8cef-c75bd312dd78

.bash_aliases

@@ -61,6 +61,10 @@ alias pshosers="ps axeo pcpu,pid,user,command | sort -k 1 -r | head -11 "
 alias memhosers="ps axeo size,pcpu,pid,user,command | sort -n -r | head -11 "
 alias psx="ps auxwww | grep $1"
 
+#work
+alias totemp="cd `pwd | sed 's/controllers/templates/'`"
+alias tocont="cd `pwd | sed 's/templates/controllers/'`"
+
 #Some orly aliases
 alias yarly="orly -y"
 alias nowai="orly -n"

.bashrc

@@ -85,3 +85,8 @@ fi
 if [ -f /etc/bash_completion ]; then
     . /etc/bash_completion
 fi
+
+if [ -n "`which fortune`" ]; then
+    fortune
+fi
+

.vim/closetag.vim

@@ -0,0 +1,327 @@
+" File: closetag.vim
+" Summary: Functions and mappings to close open HTML/XML tags
+" Uses: <C-_> -- close matching open tag
+" Author: Steven Mueller <diffusor@ugcs.caltech.edu>
+" Last Modified: Tue May 24 13:29:48 PDT 2005 
+" Version: 0.9.1
+" XXX - breaks if close attempted while XIM is in preedit mode
+" TODO - allow usability as a global plugin -
+"    Add g:unaryTagsStack - always contains html tags settings
+"    and g:closetag_default_xml - user should define this to default to xml
+"    When a close is attempted but b:unaryTagsStack undefined,
+"    use b:closetag_html_style to determine if the file is to be treated
+"    as html or xml.  Failing that, check the filetype for xml or html.
+"    Finally, default to g:closetag_html_style.
+"    If the file is html, let b:unaryTagsStack=g:unaryTagsStack
+"    otherwise, let b:unaryTagsStack=""
+" TODO - make matching work for all comments
+"  -- kinda works now, but needs syn sync minlines to be very long
+"  -- Only check whether in syntax in the beginning, then store comment tags
+"  in the tagstacks to determine whether to move into or out of comment mode
+" TODO - The new normal mode mapping clears recent messages with its <ESC>, and
+" it doesn't fix the null-undo issue for vim 5.7 anyway.
+" TODO - make use of the following neat features:
+"  -- the ternary ?: operator
+"  -- :echomsg and :echoerr
+"  -- curly brace expansion for variables and function name definitions?
+"  -- check up on map <blah> \FuncName
+"
+" Description:
+" This script eases redundant typing when writing html or xml files (even if
+" you're very good with ctrl-p and ctrl-n  :).  Hitting ctrl-_ will initiate a
+" search for the most recent open tag above that is not closed in the
+" intervening space and then insert the matching close tag at the cursor.  In
+" normal mode, the close tag is inserted one character after cursor rather than
+" at it, as if a<C-_> had been used.  This allows putting close tags at the
+" ends of lines while in normal mode, but disallows inserting them in the
+" first column.
+"
+" For HTML, a configurable list of tags are ignored in the matching process.
+" By default, the following tags will not be matched and thus not closed
+" automatically: area, base, br, dd, dt, hr, img, input, link, meta, and
+" param.
+"
+" For XML, all tags must have a closing match or be terminated by />, as in
+" <empty-element/>.  These empty element tags are ignored for matching.
+"
+" Comment checking is now handled by vim's internal syntax checking.  If tag
+" closing is initiated outside a comment, only tags outside of comments will
+" be matched.  When closing tags in comments, only tags within comments will
+" be matched, skipping any non-commented out code (wee!).  However, the
+" process of determining the syntax ID of an arbitrary position can still be
+" erroneous if a comment is not detected because the syntax highlighting is
+" out of sync, or really slow if syn sync minlines is large.
+" Set the b:closetag_disable_synID variable to disable this feature if you
+" have really big chunks of comment in your code and closing tags is too slow.
+" 
+" If syntax highlighting is not enabled, comments will not be handled very
+" well.  Commenting out HTML in certain ways may cause a "tag mismatch"
+" message and no completion.  For example, '<!--a href="blah">link!</a-->'
+" between the cursor and the most recent unclosed open tag above causes
+" trouble.  Properly matched well formed tags in comments don't cause a
+" problem.
+"
+" Install:
+" To use, place this file in your standard vim scripts directory, and source
+" it while editing the file you wish to close tags in.  If the filetype is not
+" set or the file is some sort of template with embedded HTML, you may force
+" HTML style tag matching by first defining the b:closetag_html_style buffer
+" variable.  Otherwise, the default is XML style tag matching.
+"
+" Example:
+"   :let b:closetag_html_style=1
+"   :source ~/.vim/scripts/closetag.vim
+"
+" For greater convenience, load this script in an autocommand:
+"   :au Filetype html,xml,xsl source ~/.vim/scripts/closetag.vim
+"
+" Also, set noignorecase for html files or edit b:unaryTagsStack to match your
+" capitalization style.  You may set this variable before or after loading the
+" script, or simply change the file itself.
+"
+" Configuration Variables:
+"
+" b:unaryTagsStack        Buffer local string containing a whitespace
+"                         seperated list of element names that should be
+"                         ignored while finding matching closetags.  Checking
+"                         is done according to the current setting of the
+"                         ignorecase option.
+"
+" b:closetag_html_style   Define this (as with let b:closetag_html_style=1)
+"                         and source the script again to set the
+"                         unaryTagsStack to its default value for html.
+"
+" b:closetag_disable_synID  Define this to disable comment checking if tag
+"                         closing is too slow.  This can be set or unset
+"                         without having to source again.
+"
+" Changelog:
+" May 24, 2005 Tuesday
+"   * Changed function names to be script-local to avoid conflicts with other
+"     scripts' stack implementations.
+"
+" June 07, 2001 Thursday
+"   * Added comment handling.  Currently relies on synID, so if syn sync
+"     minlines is small, the chance for failure is high, but if minlines is
+"     large, tagclosing becomes rather slow...
+"
+"   * Changed normal mode closetag mapping to use <C-R> in insert mode
+"     rather than p in normal mode.  This has 2 implications:
+"       - Tag closing no longer clobbers the unnamed register
+"       - When tag closing fails or finds no match, no longer adds to the undo
+"         buffer for recent vim 6.0 development versions.
+"       - However, clears the last message when closing tags in normal mode
+"   
+"   * Changed the closetag_html_style variable to be buffer-local rather than
+"     global.
+"
+"   * Expanded documentation
+
+"------------------------------------------------------------------------------
+" User configurable settings
+"------------------------------------------------------------------------------
+
+" if html, don't close certain tags.  Works best if ignorecase is set.
+" otherwise, capitalize these elements according to your html editing style
+if !exists("b:unaryTagsStack") || exists("b:closetag_html_style")
+    if &filetype == "html" || exists("b:closetag_html_style")
+	let b:unaryTagsStack="area base br dd dt hr img input link meta param"
+    else " for xsl and xsl
+	let b:unaryTagsStack=""
+    endif
+endif
+
+" Has this already been loaded?
+if exists("loaded_closetag")
+    finish
+endif
+let loaded_closetag=1
+
+" set up mappings for tag closing
+inoremap <C-_> <C-R>=GetCloseTag()<CR>
+map <C-_> a<C-_><ESC>
+
+"------------------------------------------------------------------------------
+" Tag closer - uses the stringstack implementation below
+"------------------------------------------------------------------------------
+
+" Returns the most recent unclosed tag-name
+" (ignores tags in the variable referenced by a:unaryTagsStack)
+function! GetLastOpenTag(unaryTagsStack)
+    " Search backwards through the file line by line using getline()
+    " Overall strategy (moving backwards through the file from the cursor):
+    "  Push closing tags onto a stack.
+    "  On an opening tag, if the tag matches the stack top, discard both.
+    "   -- if the tag doesn't match, signal an error.
+    "   -- if the stack is empty, use this tag
+    let linenum=line(".")
+    let lineend=col(".") - 1 " start: cursor position
+    let first=1              " flag for first line searched
+    let b:TagStack=""        " main stack of tags
+    let startInComment=s:InComment()
+
+    let tagpat='</\=\(\k\|[-:]\)\+\|/>'
+    " Search for: closing tags </tag, opening tags <tag, and unary tag ends />
+    while (linenum>0)
+	" Every time we see an end-tag, we push it on the stack.  When we see an
+	" open tag, if the stack isn't empty, we pop it and see if they match.
+	" If no, signal an error.
+	" If yes, continue searching backwards.
+	" If stack is empty, return this open tag as the one that needs closing.
+	let line=getline(linenum)
+	if first
+	    let line=strpart(line,0,lineend)
+	else
+	    let lineend=strlen(line)
+	endif
+	let b:lineTagStack=""
+	let mpos=0
+	let b:TagCol=0
+	" Search the current line in the forward direction, pushing any tags
+	" onto a special stack for the current line
+	while (mpos > -1)
+	    let mpos=matchend(line,tagpat)
+	    if mpos > -1
+		let b:TagCol=b:TagCol+mpos
+		let tag=matchstr(line,tagpat)
+		
+		if exists("b:closetag_disable_synID") || startInComment==s:InCommentAt(linenum, b:TagCol)
+		  let b:TagLine=linenum
+		  call s:Push(matchstr(tag,'[^<>]\+'),"b:lineTagStack")
+		endif
+		"echo "Tag: ".tag." ending at position ".mpos." in '".line."'."
+		let lineend=lineend-mpos
+		let line=strpart(line,mpos,lineend)
+	    endif
+	endwhile
+	" Process the current line stack
+	while (!s:EmptystackP("b:lineTagStack"))
+	    let tag=s:Pop("b:lineTagStack")
+	    if match(tag, "^/") == 0		"found end tag
+		call s:Push(tag,"b:TagStack")
+		"echo linenum." ".b:TagStack
+	    elseif s:EmptystackP("b:TagStack") && !s:Instack(tag, a:unaryTagsStack)	"found unclosed tag
+		return tag
+	    else
+		let endtag=s:Peekstack("b:TagStack")
+		if endtag == "/".tag || endtag == "/"
+		    call s:Pop("b:TagStack")	"found a open/close tag pair
+		    "echo linenum." ".b:TagStack
+		elseif !s:Instack(tag, a:unaryTagsStack) "we have a mismatch error
+		    echohl Error
+		    echon "\rError:"
+		    echohl None
+		    echo " tag mismatch: <".tag."> doesn't match <".endtag.">.  (Line ".linenum." Tagstack: ".b:TagStack.")"
+		    return ""
+		endif
+	    endif
+	endwhile
+	let linenum=linenum-1 | let first=0
+    endwhile
+    " At this point, we have exhausted the file and not found any opening tag
+    echo "No opening tags."
+    return ""
+endfunction
+
+" Returns closing tag for most recent unclosed tag, respecting the
+" current setting of b:unaryTagsStack for tags that should not be closed
+function! GetCloseTag()
+    let tag=GetLastOpenTag("b:unaryTagsStack")
+    if tag == ""
+	return ""
+    else
+	return "</".tag.">"
+    endif
+endfunction
+
+" return 1 if the cursor is in a syntactically identified comment field
+" (fails for empty lines: always returns not-in-comment)
+function! s:InComment()
+    return synIDattr(synID(line("."), col("."), 0), "name") =~ 'Comment'
+endfunction
+
+" return 1 if the position specified is in a syntactically identified comment field
+function! s:InCommentAt(line, col)
+    return synIDattr(synID(a:line, a:col, 0), "name") =~ 'Comment'
+endfunction
+
+"------------------------------------------------------------------------------
+" String Stacks
+"------------------------------------------------------------------------------
+" These are strings of whitespace-separated elements, matched using the \< and
+" \> patterns after setting the iskeyword option.
+" 
+" The sname argument should contain a symbolic reference to the stack variable
+" on which method should operate on (i.e., sname should be a string containing
+" a fully qualified (ie: g:, b:, etc) variable name.)
+
+" Helper functions
+function! s:SetKeywords()
+    let g:IsKeywordBak=&iskeyword
+    let &iskeyword="33-255"
+endfunction
+
+function! s:RestoreKeywords()
+    let &iskeyword=g:IsKeywordBak
+endfunction
+
+" Push el onto the stack referenced by sname
+function! s:Push(el, sname)
+    if !s:EmptystackP(a:sname)
+	exe "let ".a:sname."=a:el.' '.".a:sname
+    else
+	exe "let ".a:sname."=a:el"
+    endif
+endfunction
+
+" Check whether the stack is empty
+function! s:EmptystackP(sname)
+    exe "let stack=".a:sname
+    if match(stack,"^ *$") == 0
+	return 1
+    else
+	return 0
+    endif
+endfunction
+
+" Return 1 if el is in stack sname, else 0.
+function! s:Instack(el, sname)
+    exe "let stack=".a:sname
+    call s:SetKeywords()
+    let m=match(stack, "\\<".a:el."\\>")
+    call s:RestoreKeywords()
+    if m < 0
+	return 0
+    else
+	return 1
+    endif
+endfunction
+
+" Return the first element in the stack
+function! s:Peekstack(sname)
+    call s:SetKeywords()
+    exe "let stack=".a:sname
+    let top=matchstr(stack, "\\<.\\{-1,}\\>")
+    call s:RestoreKeywords()
+    return top
+endfunction
+
+" Remove and return the first element in the stack
+function! s:Pop(sname)
+    if s:EmptystackP(a:sname)
+	echo "Error!  Stack ".a:sname." is empty and can't be popped."
+	return ""
+    endif
+    exe "let stack=".a:sname
+    " Find the first space, loc is 0-based.  Marks the end of 1st elt in stack.
+    call s:SetKeywords()
+    let loc=matchend(stack,"\\<.\\{-1,}\\>")
+    exe "let ".a:sname."=strpart(stack, loc+1, strlen(stack))"
+    let top=strpart(stack, match(stack, "\\<"), loc)
+    call s:RestoreKeywords()
+    return top
+endfunction
+
+function! s:Clearstack(sname)
+    exe "let ".a:sname."=''"
+endfunction

.vim/colors/barak.vim

@@ -53,6 +53,15 @@ endif
 " syntax hi colors
 hi Comment	term=bold ctermfg=darkgreen guifg=ForestGreen
 hi PreProc	term=underline ctermfg=darkmagenta guifg=magenta3
+
+hi makoDelim term=underline ctermfg=darkyellow guifg=goldenrod1 guibg=gray25
+hi makoAttributeKey term=underline ctermfg=darkcyan gui=bold guifg=turquoise3 guibg=gray25
+hi makoAttributeValue term=underline ctermfg=red guifg=firebrick3 guibg=gray25
+hi makoText ctermfg=gray guifg=gray55 guibg=gray25
+hi makoEnd term=bold ctermfg=blue gui=bold guifg=RoyalBlue1 guibg=gray25
+hi makoComment term=bold ctermfg=darkgreen guifg=ForestGreen guibg=gray25
+hi makoEscape term=underline ctermfg=brown guifg=khaki3 guibg=gray25
+
 hi Constant	term=underline ctermfg=red guifg=#b62f61
 hi String	term=underline ctermfg=red guifg=firebrick3
 hi Boolean	term=underline ctermfg=magenta guifg=LightSalmon1

.vim/doc/matchit.txt

@@ -0,0 +1,406 @@
+*matchit.txt*   Extended "%" matching
+
+For instructions on installing this file, type
+	:help matchit-install
+inside Vim.
+
+For Vim version 6.3.  Last change:  2007 Aug 29
+
+
+		  VIM REFERENCE MANUAL    by Benji Fisher
+
+*matchit* *matchit.vim*
+
+1. Extended matching with "%"				|matchit-intro|
+2. Activation						|matchit-activate|
+3. Configuration					|matchit-configure|
+4. Supporting a New Language				|matchit-newlang|
+5. Known Bugs and Limitations				|matchit-bugs|
+
+The functionality mentioned here is a plugin, see |add-plugin|.
+This plugin is only available if 'compatible' is not set.
+You can avoid loading this plugin by setting the "loaded_matchit" variable
+in your |vimrc| file: >
+	:let loaded_matchit = 1
+
+{Vi does not have any of this}
+
+==============================================================================
+1. Extended matching with "%"				*matchit-intro*
+
+							*matchit-%*
+%	Cycle forward through matching groups, such as "if", "else", "endif",
+	as specified by |b:match_words|.
+
+							*g%* *v_g%* *o_g%*
+g%	Cycle backwards through matching groups, as specified by
+	|b:match_words|.  For example, go from "if" to "endif" to "else".
+
+							*[%* *v_[%* *o_[%*
+[%	Go to [count] previous unmatched group, as specified by
+	|b:match_words|.  Similar to |[{|.
+
+							*]%* *v_]%* *o_]%*
+]%	Go to [count] next unmatched group, as specified by
+	|b:match_words|.  Similar to |]}|.
+
+							*v_a%*
+a%	In Visual mode, select the matching group, as specified by
+	|b:match_words|, containing the cursor.  Similar to |v_a[|.
+	A [count] is ignored, and only the first character of the closing
+	pattern is selected.
+
+In Vim, as in plain vi, the percent key, |%|, jumps the cursor from a brace,
+bracket, or paren to its match.  This can be configured with the 'matchpairs'
+option.  The matchit plugin extends this in several ways:
+
+	    You can match whole words, such as "if" and "endif", not just
+	single characters.  You can also specify a |regular-expression|.
+	    You can define groups with more than two words, such as "if",
+	"else", "endif".  Banging on the "%" key will cycle from the "if" to
+	the first "else", the next "else", ..., the closing "endif", and back
+	to the opening "if".  Nested structures are skipped.  Using |g%| goes
+	in the reverse direction.
+	    By default, words inside comments and strings are ignored, unless
+	the cursor is inside a comment or string when you type "%".  If the
+	only thing you want to do is modify the behavior of "%" so that it
+	behaves this way, you do not have to define |b:match_words|, since the
+	script uses the 'matchpairs' option as well as this variable.
+
+See |matchit-details| for details on what the script does, and |b:match_words|
+for how to specify matching patterns.
+
+MODES:			*matchit-modes* *matchit-v_%* *matchit-o_%*
+
+Mostly, % and related motions (|g%| and |[%| and |]%|) work just like built-in
+|motion| commands in |Operator-pending| and |Visual| modes.  However, you
+cannot make these motions |linewise| or |characterwise|, since the |:omap|s
+that define them start with "v" in order to make the default behavior
+inclusive.  (See |o_v|.)  In other words, "dV%" will not work.  The
+work-around is to go through Visual mode:  "V%d" will work.
+
+LANGUAGES:					*matchit-languages*
+
+Currently, the following languages are supported:  Ada, ASP with VBS, Csh,
+DTD, Entity, Essbase, Fortran, HTML, JSP (same as HTML), LaTeX, Lua, Pascal,
+SGML, Shell, Tcsh, Vim, XML.  Other languages may already have support via
+the default |filetype-plugin|s in the standard vim distribution.
+
+To support a new language, see |matchit-newlang| below.
+
+DETAILS:				*matchit-details* *matchit-parse*
+
+Here is an outline of what matchit.vim does each time you hit the "%" key.  If
+there are |backref|s in |b:match_words| then the first step is to produce a
+version in which these back references have been eliminated; if there are no
+|backref|s then this step is skipped.  This step is called parsing.  For
+example, "\(foo\|bar\):end\1" is parsed to yield
+"\(foo\|bar\):end\(foo\|bar\)".  This can get tricky, especially if there are
+nested groups.  If debugging is turned on, the parsed version is saved as
+|b:match_pat|.
+
+							*matchit-choose*
+Next, the script looks for a word on the current line that matches the pattern
+just constructed.  It includes the patterns from the 'matchpairs' option.
+The goal is to do what you expect, which turns out to be a little complicated.
+The script follows these rules:
+
+	Insist on a match that ends on or after the cursor.
+	Prefer a match that includes the cursor position (that is, one that
+		starts on or before the cursor).
+	Prefer a match that starts as close to the cursor as possible.
+	If more than one pattern in |b:match_words| matches, choose the one
+		that is listed first.
+
+Examples:
+
+	Suppose you >
+		:let b:match_words = '<:>,<tag>:</tag>'
+<	and hit "%" with the cursor on or before the "<" in "a <tag> is born".
+	The pattern '<' comes first, so it is preferred over '<tag>', which
+	also matches.  If the cursor is on the "t", however, then '<tag>' is
+	preferred, because this matches a bit of text containing the cursor.
+	If the two groups of patterns were reversed then '<' would never be
+	preferred.
+
+	Suppose you >
+		:let b:match_words = 'if:end if'
+<	(Note the space!) and hit "%" with the cursor at the end of "end if".
+	Then "if" matches, which is probably not what you want, but if the
+	cursor starts on the "end " then "end if" is chosen.  (You can avoid
+	this problem by using a more complicated pattern.)
+
+If there is no match, the cursor does not move.  (Before version 1.13 of the
+script, it would fall back on the usual behavior of |%|).  If debugging is
+turned on, the matched bit of text is saved as |b:match_match| and the cursor
+column of the start of the match is saved as |b:match_col|.
+
+Next, the script looks through |b:match_words| (original and parsed versions)
+for the group and pattern that match.  If debugging is turned on, the group is
+saved as |b:match_ini| (the first pattern) and |b:match_tail| (the rest).  If
+there are |backref|s then, in addition, the matching pattern is saved as
+|b:match_word| and a table of translations is saved as |b:match_table|.  If
+there are |backref|s, these are determined from the matching pattern and
+|b:match_match| and substituted into each pattern in the matching group.
+
+The script decides whether to search forwards or backwards and chooses
+arguments for the |searchpair()| function.  Then, the cursor is moved to the
+start of the match, and |searchpair()| is called.  By default, matching
+structures inside strings and comments are ignored.  This can be changed by
+setting |b:match_skip|.
+
+==============================================================================
+2. Activation						*matchit-activate*
+
+You can use this script as a plugin, by copying it to your plugin directory.
+See |add-global-plugin| for instructions.  You can also add a line to your
+|vimrc| file, such as >
+	:source $VIMRUNTIME/macros/matchit.vim
+or >
+	:runtime macros/matchit.vim
+Either way, the script should start working the next time you start up Vim.
+
+(Earlier versions of the script did nothing unless a |buffer-variable| named
+|b:match_words| was defined.  Even earlier versions contained autocommands
+that set this variable for various file types.  Now, |b:match_words| is
+defined in many of the default |filetype-plugin|s instead.)
+
+For a new language, you can add autocommands to the script or to your vimrc
+file, but the recommended method is to add a line such as >
+	let b:match_words = '\<foo\>:\<bar\>'
+to the |filetype-plugin| for your language.  See |b:match_words| below for how
+this variable is interpreted.
+
+TROUBLESHOOTING					*matchit-troubleshoot*
+
+The script should work in most installations of Vim.  It may not work if Vim
+was compiled with a minimal feature set, for example if the |+syntax| option
+was not enabled.  If your Vim has support for syntax compiled in, but you do
+not have |syntax| highlighting turned on, matchit.vim should work, but it may
+fail to skip matching groups in comments and strings.  If the |filetype|
+mechanism is turned off, the |b:match_words| variable will probably not be
+defined automatically.
+
+==============================================================================
+3. Configuration					*matchit-configure*
+
+There are several variables that govern the behavior of matchit.vim.  Note
+that these are variables local to the buffer, not options, so use |:let| to
+define them, not |:set|.  Some of these variables have values that matter; for
+others, it only matters whether the variable has been defined.  All of these
+can be defined in the |filetype-plugin| or autocommand that defines
+|b:match_words| or "on the fly."
+
+The main variable is |b:match_words|.  It is described in the section below on
+supporting a new language.
+
+				*MatchError* *matchit-hl* *matchit-highlight*
+MatchError is the highlight group for error messages from the script.  By
+default, it is linked to WarningMsg.  If you do not want to be bothered by
+error messages, you can define this to be something invisible.  For example,
+if you use the GUI version of Vim and your command line is normally white, you
+can do >
+	:hi MatchError guifg=white guibg=white
+<
+						*b:match_ignorecase*
+If you >
+	:let b:match_ignorecase = 1
+then matchit.vim acts as if 'ignorecase' is set: for example, "end" and "END"
+are equivalent.  If you >
+	:let b:match_ignorecase = 0
+then matchit.vim treats "end" and "END" differently.  (There will be no
+b:match_infercase option unless someone requests it.)
+
+						*b:match_debug*
+Define b:match_debug if you want debugging information to be saved.  See
+|matchit-debug|, below.
+
+						*b:match_skip*
+If b:match_skip is defined, it is passed as the skip argument to
+|searchpair()|.  This controls when matching structures are skipped, or
+ignored.  By default, they are ignored inside comments and strings, as
+determined by the |syntax| mechanism.  (If syntax highlighting is turned off,
+nothing is skipped.)  You can set b:match_skip to a string, which evaluates to
+a non-zero, numerical value if the match is to be skipped or zero if the match
+should not be skipped.  In addition, the following special values are
+supported by matchit.vim:
+	s:foo becomes (current syntax item) =~ foo
+	S:foo becomes (current syntax item) !~ foo
+	r:foo becomes (line before cursor) =~ foo
+	R:foo becomes (line before cursor) !~ foo
+(The "s" is meant to suggest "syntax", and the "r" is meant to suggest
+"regular expression".)
+
+Examples:
+
+	You can get the default behavior with >
+		:let b:match_skip = 's:comment\|string'
+<
+	If you want to skip matching structures unless they are at the start
+	of the line (ignoring whitespace) then you can >
+		:let b:match_skip = 'R:^\s*'
+<	Do not do this if strings or comments can span several lines, since
+	the normal syntax checking will not be done if you set b:match_skip.
+
+	In LaTeX, since "%" is used as the comment character, you can >
+		:let b:match_skip = 'r:%'
+<	Unfortunately, this will skip anything after "\%", an escaped "%".  To
+	allow for this, and also "\\%" (an excaped backslash followed by the
+	comment character) you can >
+		:let b:match_skip = 'r:\(^\|[^\\]\)\(\\\\\)*%'
+<
+	See the $VIMRUNTIME/ftplugin/vim.vim for an example that uses both
+	syntax and a regular expression.
+
+==============================================================================
+4. Supporting a New Language				*matchit-newlang*
+							*b:match_words*
+In order for matchit.vim to support a new language, you must define a suitable
+pattern for |b:match_words|.  You may also want to set some of the
+|matchit-configure| variables, as described above.  If your language has a
+complicated syntax, or many keywords, you will need to know something about
+Vim's |regular-expression|s.
+
+The format for |b:match_words| is similar to that of the 'matchpairs' option:
+it is a comma (,)-separated list of groups; each group is a colon(:)-separated
+list of patterns (regular expressions).  Commas and backslashes that are part
+of a pattern should be escaped with backslashes ('\:' and '\,').  It is OK to
+have only one group; the effect is undefined if a group has only one pattern.
+A simple example is >
+	:let b:match_words = '\<if\>:\<endif\>,'
+		\ . '\<while\>:\<continue\>:\<break\>:\<endwhile\>'
+(In Vim regular expressions, |\<| and |\>| denote word boundaries.  Thus "if"
+matches the end of "endif" but "\<if\>" does not.)  Then banging on the "%"
+key will bounce the cursor between "if" and the matching "endif"; and from
+"while" to any matching "continue" or "break", then to the matching "endwhile"
+and back to the "while".  It is almost always easier to use |literal-string|s
+(single quotes) as above:  '\<if\>' rather than "\\<if\\>" and so on.
+
+Exception:  If the ":" character does not appear in b:match_words, then it is
+treated as an expression to be evaluated.  For example, >
+	:let b:match_words = 'GetMatchWords()'
+allows you to define a function.  This can return a different string depending
+on the current syntax, for example.
+
+Once you have defined the appropriate value of |b:match_words|, you will
+probably want to have this set automatically each time you edit the
+appropriate file type.  The recommended way to do this is by adding the
+definition to a |filetype-plugin| file.
+
+Tips: Be careful that your initial pattern does not match your final pattern.
+See the example above for the use of word-boundary expressions.  It is usually
+better to use ".\{-}" (as many as necessary) instead of ".*" (as many as
+possible).  See |\{-|.  For example, in the string "<tag>label</tag>", "<.*>"
+matches the whole string whereas "<.\{-}>" and "<[^>]*>" match "<tag>" and
+"</tag>".
+
+				*matchit-spaces* *matchit-s:notend*
+If "if" is to be paired with "end if" (Note the space!) then word boundaries
+are not enough.  Instead, define a regular expression s:notend that will match
+anything but "end" and use it as follows: >
+	:let s:notend = '\%(\<end\s\+\)\@<!'
+	:let b:match_words = s:notend . '\<if\>:\<end\s\+if\>'
+<							*matchit-s:sol*
+This is a simplified version of what is done for Ada.  The s:notend is a
+|script-variable|.  Similarly, you may want to define a start-of-line regular
+expression >
+	:let s:sol = '\%(^\|;\)\s*'
+if keywords are only recognized after the start of a line or after a
+semicolon (;), with optional white space.
+
+					*matchit-backref* *matchit-\1*
+In any group, the expressions |\1|, |\2|, ..., |\9| refer to parts of the
+INITIAL pattern enclosed in |\(|escaped parentheses|\)|.  These are referred
+to as back references, or backrefs.  For example, >
+	:let b:match_words = '\<b\(o\+\)\>:\(h\)\1\>'
+means that "bo" pairs with "ho" and "boo" pairs with "hoo" and so on.  Note
+that "\1" does not refer to the "\(h\)" in this example.  If you have
+"\(nested \(parentheses\)\) then "\d" refers to the d-th "\(" and everything
+up to and including the matching "\)":  in "\(nested\(parentheses\)\)", "\1"
+refers to everything and "\2" refers to "\(parentheses\)".  If you use a
+variable such as |s:notend| or |s:sol| in the previous paragraph then remember
+to count any "\(" patterns in this variable.  You do not have to count groups
+defined by |\%(\)|.
+
+It should be possible to resolve back references from any pattern in the
+group.  For example, >
+	:let b:match_words = '\(foo\)\(bar\):more\1:and\2:end\1\2'
+would not work because "\2" cannot be determined from "morefoo" and "\1"
+cannot be determined from "andbar".  On the other hand, >
+	:let b:match_words = '\(\(foo\)\(bar\)\):\3\2:end\1'
+should work (and have the same effect as "foobar:barfoo:endfoobar"), although
+this has not been thoroughly tested.
+
+You can use |zero-width| patterns such as |\@<=| and |\zs|.  (The latter has
+not been thouroughly tested in matchit.vim.)  For example, if the keyword "if"
+must occur at the start of the line, with optional white space, you might use
+the pattern "\(^\s*\)\@<=if" so that the cursor will end on the "i" instead of
+at the start of the line.  For another example, if HTML had only one tag then
+one could >
+	:let b:match_words = '<:>,<\@<=tag>:<\@<=/tag>'
+so that "%" can bounce between matching "<" and ">" pairs or (starting on
+"tag" or "/tag") between matching tags.  Without the |\@<=|, the script would
+bounce from "tag" to the "<" in "</tag>", and another "%" would not take you
+back to where you started.
+
+DEBUGGING				*matchit-debug* *:MatchDebug*
+
+If you are having trouble figuring out the appropriate definition of
+|b:match_words| then you can take advantage of the same information I use when
+debugging the script.  This is especially true if you are not sure whether
+your patterns or my script are at fault!  To make this more convenient, I have
+made the command :MatchDebug, which defines the variable |b:match_debug| and
+creates a Matchit menu.  This menu makes it convenient to check the values of
+the variables described below.  You will probably also want to read
+|matchit-details| above.
+
+Defining the variable |b:match_debug| causes the script to set the following
+variables, each time you hit the "%" key.  Several of these are only defined
+if |b:match_words| includes |backref|s.
+
+							*b:match_pat*
+The b:match_pat variable is set to |b:match_words| with |backref|s parsed.
+							*b:match_match*
+The b:match_match variable is set to the bit of text that is recognized as a
+match.
+							*b:match_col*
+The b:match_col variable is set to the cursor column of the start of the
+matching text.
+							*b:match_wholeBR*
+The b:match_wholeBR variable is set to the comma-separated group of patterns
+that matches, with |backref|s unparsed.
+							*b:match_iniBR*
+The b:match_iniBR variable is set to the first pattern in |b:match_wholeBR|.
+							*b:match_ini*
+The b:match_ini variable is set to the first pattern in |b:match_wholeBR|,
+with |backref|s resolved from |b:match_match|.
+							*b:match_tail*
+The b:match_tail variable is set to the remaining patterns in
+|b:match_wholeBR|, with |backref|s resolved from |b:match_match|.
+							*b:match_word*
+The b:match_word variable is set to the pattern from |b:match_wholeBR| that
+matches |b:match_match|.
+							*b:match_table*
+The back reference '\'.d refers to the same thing as '\'.b:match_table[d] in
+|b:match_word|.
+
+==============================================================================
+5. Known Bugs and Limitations				*matchit-bugs*
+
+Just because I know about a bug does not mean that it is on my todo list.  I
+try to respond to reports of bugs that cause real problems.  If it does not
+cause serious problems, or if there is a work-around, a bug may sit there for
+a while.  Moral:  if a bug (known or not) bothers you, let me know.
+
+The various |:vmap|s defined in the script (%, |g%|, |[%|, |]%|, |a%|) may
+have undesired effects in Select mode |Select-mode-mapping|.  At least, if you
+want to replace the selection with any character in "ag%[]" there will be a
+pause of |'updatetime'| first.
+
+It would be nice if "\0" were recognized as the entire pattern.  That is, it
+would be nice if "foo:\end\0" had the same effect as "\(foo\):\end\1".  I may
+try to implement this in a future version.  (This is not so easy to arrange as
+you might think!)
+
+==============================================================================
+vim:tw=78:fo=tcq2:

.vim/doc/tags

@@ -7,6 +7,7 @@
 :CVSWatchOn	vcscommand.txt	/*:CVSWatchOn*
 :CVSWatchRemove	vcscommand.txt	/*:CVSWatchRemove*
 :CVSWatchers	vcscommand.txt	/*:CVSWatchers*
+:MatchDebug	matchit.txt	/*:MatchDebug*
 :VCSAdd	vcscommand.txt	/*:VCSAdd*
 :VCSAnnotate	vcscommand.txt	/*:VCSAnnotate*
 :VCSBlame	vcscommand.txt	/*:VCSBlame*
@@ -24,6 +25,7 @@
 :VCSUnlock	vcscommand.txt	/*:VCSUnlock*
 :VCSUpdate	vcscommand.txt	/*:VCSUpdate*
 :VCSVimDiff	vcscommand.txt	/*:VCSVimDiff*
+MatchError	matchit.txt	/*MatchError*
 VCSCommandCVSDiffOpt	vcscommand.txt	/*VCSCommandCVSDiffOpt*
 VCSCommandCVSExec	vcscommand.txt	/*VCSCommandCVSExec*
 VCSCommandCommitOnWrite	vcscommand.txt	/*VCSCommandCommitOnWrite*
@@ -40,10 +42,25 @@ VCSCommandSVNDiffExt	vcscommand.txt	/*VCSCommandSVNDiffExt*
 VCSCommandSVNDiffOpt	vcscommand.txt	/*VCSCommandSVNDiffOpt*
 VCSCommandSVNExec	vcscommand.txt	/*VCSCommandSVNExec*
 VCSCommandSplit	vcscommand.txt	/*VCSCommandSplit*
+[%	matchit.txt	/*[%*
+]%	matchit.txt	/*]%*
 b:VCSCommandCommand	vcscommand.txt	/*b:VCSCommandCommand*
 b:VCSCommandOriginalBuffer	vcscommand.txt	/*b:VCSCommandOriginalBuffer*
 b:VCSCommandSourceFile	vcscommand.txt	/*b:VCSCommandSourceFile*
 b:VCSCommandVCSType	vcscommand.txt	/*b:VCSCommandVCSType*
+b:match_col	matchit.txt	/*b:match_col*
+b:match_debug	matchit.txt	/*b:match_debug*
+b:match_ignorecase	matchit.txt	/*b:match_ignorecase*
+b:match_ini	matchit.txt	/*b:match_ini*
+b:match_iniBR	matchit.txt	/*b:match_iniBR*
+b:match_match	matchit.txt	/*b:match_match*
+b:match_pat	matchit.txt	/*b:match_pat*
+b:match_skip	matchit.txt	/*b:match_skip*
+b:match_table	matchit.txt	/*b:match_table*
+b:match_tail	matchit.txt	/*b:match_tail*
+b:match_wholeBR	matchit.txt	/*b:match_wholeBR*
+b:match_word	matchit.txt	/*b:match_word*
+b:match_words	matchit.txt	/*b:match_words*
 cs	surround.txt	/*cs*
 cvscommand-changes	vcscommand.txt	/*cvscommand-changes*
 drawit	DrawIt.txt	/*drawit*
@@ -74,9 +91,38 @@ drawit-usage	DrawIt.txt	/*drawit-usage*
 drawit-visblock	DrawIt.txt	/*drawit-visblock*
 drawit.txt	DrawIt.txt	/*drawit.txt*
 ds	surround.txt	/*ds*
+g%	matchit.txt	/*g%*
 g:drawit_insertmode	DrawIt.txt	/*g:drawit_insertmode*
 i_CTRL-G_S	surround.txt	/*i_CTRL-G_S*
 i_CTRL-G_s	surround.txt	/*i_CTRL-G_s*
+matchit	matchit.txt	/*matchit*
+matchit-%	matchit.txt	/*matchit-%*
+matchit-\1	matchit.txt	/*matchit-\\1*
+matchit-activate	matchit.txt	/*matchit-activate*
+matchit-backref	matchit.txt	/*matchit-backref*
+matchit-bugs	matchit.txt	/*matchit-bugs*
+matchit-choose	matchit.txt	/*matchit-choose*
+matchit-configure	matchit.txt	/*matchit-configure*
+matchit-debug	matchit.txt	/*matchit-debug*
+matchit-details	matchit.txt	/*matchit-details*
+matchit-highlight	matchit.txt	/*matchit-highlight*
+matchit-hl	matchit.txt	/*matchit-hl*
+matchit-intro	matchit.txt	/*matchit-intro*
+matchit-languages	matchit.txt	/*matchit-languages*
+matchit-modes	matchit.txt	/*matchit-modes*
+matchit-newlang	matchit.txt	/*matchit-newlang*
+matchit-o_%	matchit.txt	/*matchit-o_%*
+matchit-parse	matchit.txt	/*matchit-parse*
+matchit-s:notend	matchit.txt	/*matchit-s:notend*
+matchit-s:sol	matchit.txt	/*matchit-s:sol*
+matchit-spaces	matchit.txt	/*matchit-spaces*
+matchit-troubleshoot	matchit.txt	/*matchit-troubleshoot*
+matchit-v_%	matchit.txt	/*matchit-v_%*
+matchit.txt	matchit.txt	/*matchit.txt*
+matchit.vim	matchit.txt	/*matchit.vim*
+o_[%	matchit.txt	/*o_[%*
+o_]%	matchit.txt	/*o_]%*
+o_g%	matchit.txt	/*o_g%*
 project	project.txt	/*project*
 project-adding-mappings	project.txt	/*project-adding-mappings*
 project-example	project.txt	/*project-example*
@@ -125,6 +171,10 @@ surround-mappings	surround.txt	/*surround-mappings*
 surround-replacements	surround.txt	/*surround-replacements*
 surround-targets	surround.txt	/*surround-targets*
 surround.txt	surround.txt	/*surround.txt*
+v_[%	matchit.txt	/*v_[%*
+v_]%	matchit.txt	/*v_]%*
+v_a%	matchit.txt	/*v_a%*
+v_g%	matchit.txt	/*v_g%*
 vcscommand	vcscommand.txt	/*vcscommand*
 vcscommand-buffer-management	vcscommand.txt	/*vcscommand-buffer-management*
 vcscommand-buffer-variables	vcscommand.txt	/*vcscommand-buffer-variables*

.vim/filetype.vim

@@ -5,3 +5,6 @@ endif
 augroup markdown
   au! BufRead,BufNewFile *.mkd   setfiletype mkd
 augroup END
+augroup mako
+  au! BufRead,BufNewFile *.mak   setfiletype mako
+augroup END

.vim/syntax/mako.vim

@@ -0,0 +1,83 @@
+" Vim syntax file
+" Language:     Mako
+" Maintainer:   Armin Ronacher <armin.ronacher@active-4.com>
+" URL:          http://lucumr.pocoo.org/
+" Last Change:  2007 April 8
+" Version:	0.6
+"
+" Known Limitations
+"   the <%text> block does not have correct attributes
+
+" For version 5.x: Clear all syntax items
+" For version 6.x: Quit when a syntax file was already loaded
+if version < 600
+  syntax clear
+elseif exists("b:current_syntax")
+  finish
+endif
+
+if !exists("main_syntax")
+  let main_syntax = "html"
+endif
+
+"Source the html syntax file
+ru! syntax/html.vim
+unlet b:current_syntax
+
+"Put the python syntax file in @pythonTop
+syn include @pythonTop syntax/python.vim
+
+" End keywords
+syn keyword makoEnd contained endfor endwhile endif endtry enddef
+
+" Block rules
+syn region makoLine matchgroup=makoDelim start=#%\s*# end=#$# keepend contains=@pythonTop,makoEnd
+syn region makoBlock matchgroup=makoDelim start=#<%!\?# end=#%># keepend contains=@pythonTop,makoEnd
+
+" Variables
+syn region makoNested start="{" end="}" transparent display contained contains=makoNested,@pythonTop
+syn region makoVariable matchgroup=makoDelim start=#\${# end=#}# contains=makoNested,@pythonTop
+
+" Comments
+syn region makoComment start="##" end="$"
+syn region makoDocComment matchgroup=makoDelim start="<%doc>" end="</%doc>" keepend
+
+" Literal Blocks
+syn region makoText matchgroup=makoDelim start="<%text[^>]*>" end="</%text>"
+
+" Attribute Sublexing
+syn match makoAttributeKey containedin=makoTag contained "[a-zA-Z_][a-zA-Z0-9_]*="
+syn region makoAttributeValue containedin=makoTag contained start=/"/ skip=/\\"/ end=/"/
+syn region makoAttributeValue containedin=MakoTag contained start=/'/ skip=/\\'/ end=/'/
+
+" Tags
+syn region makoTag matchgroup=makoDelim start="<%\(def\|call\|page\|include\|namespace\|inherit\)\>\s*" end="/\?>"
+syn match makoDelim "</%\(def\|call\)>"
+
+" Newline Escapes
+syn match makoEscape /\\$/
+
+" Default highlighting links
+if version >= 508 || !exists("did_mako_syn_inits")
+  if version < 508
+    let did_mako_syn_inits = 1
+    com -nargs=+ HiLink hi link <args>
+  else
+    com -nargs=+ HiLink hi def link <args>
+  endif
+
+  HiLink makoDocComment makoComment
+  HiLink makoDefEnd makoDelim
+
+  HiLink makoAttributeKey Type
+  HiLink makoAttributeValue String
+  HiLink makoText Normal
+  HiLink makoDelim Preproc
+  HiLink makoEnd Keyword
+  HiLink makoComment Comment
+  HiLink makoEscape Special
+
+  delc HiLink
+endif
+
+let b:current_syntax = "mako"

.vimrc

@@ -4,6 +4,9 @@ syntax on
 colorscheme barak
 "set gfn=Monaco:h12:a
 set ts=4
+set softtabstop=4
+set shiftwidth=4
+set expandtab
 set nocompatible
 set smartcase
 set smartindent
@@ -20,8 +23,9 @@ au BufNewFile,BufRead motd.public,/tmp/motd.public.r.* setf motd
 autocmd FileType ruby,eruby set omnifunc=rubycomplete#Complete
 autocmd FileType python set tags+=$HOME/.vim/tags/python.ctags
 autocmd FileType python set omnifunc=pythoncomplete#Complete
-autocmd FileType python call SuperTabSetCompletionType("<C-X><C-O>")
+"autocmd FileType python call SuperTabSetCompletionType("<C-X><C-O>")
 let python_highlight_all = 1
+au Filetype html,xml,xsl source ~/.vim/closetag.vim
 
 set t_Co=16
 set t_Sf=ESC[3%dm
@@ -53,6 +57,20 @@ vnoremap <C-e> $
 inoremap <C-a> <C-O>^
 inoremap <C-e> <C-O>$
 
+" , #perl # comments
+map ,# :s/^/#/<CR>
+" , #mako ## comments
+map ,% :s/^/##/<CR>
+
+" ,/ C/C++/C#/Java // comments
+map ,/ :s/^/\/\//<CR>
+
+" ,< HTML comment
+map ,< :s/^\(.*\)$/<!-- \1 -->/<CR><Esc>:nohlsearch<CR>
+
+" c++ java style comments
+map ,* :s/^\(.*\)$/\/\* \1 \*\//<CR><Esc>:nohlsearch<CR>
+
 
 if !exists(":W")
 	command W :w