diff --git a/runtime/syntax/reva.vim b/runtime/syntax/reva.vim
index 7e11ffe..03dfc9d 100644
--- a/runtime/syntax/reva.vim
+++ b/runtime/syntax/reva.vim
@@ -1,10 +1,10 @@
 " Vim syntax file
 " Language:	Reva Forth
-" Version:	7.1
-" Last Change:	2008/01/11
+" Version:	2011.2
+" Last Change:	2012/02/13
 " Maintainer:	Ron Aaron <ron@ronware.org>
 " URL:		http://ronware.org/reva/
-" Filetypes:	*.rf *.frt 
+" Filetypes:	*.rf *.frt
 " NOTE: 	You should also have the ftplugin/reva.vim file to set 'isk'
 
 " For version 5.x: Clear all syntax items and don't load
@@ -17,10 +17,13 @@
    finish
 endif
 
+let s:cpo_save = &cpo
+set cpo&vim
+
 syn clear
 
 " Synchronization method
-syn sync ccomment 
+syn sync ccomment
 syn sync maxlines=100
 
 
@@ -39,7 +42,7 @@
 syn case match
 " basic mathematical and logical operators
 syn keyword revaoperators + - * / mod /mod negate abs min max umin umax
-syn keyword revaoperators and or xor not invert 1+ 1- 
+syn keyword revaoperators and or xor not invert 1+ 1-
 syn keyword revaoperators m+ */ */mod m* um* m*/ um/mod fm/mod sm/rem
 syn keyword revaoperators d+ d- dnegate dabs dmin dmax > < = >> << u< <>
 
@@ -53,10 +56,10 @@
 " address operations
 syn keyword revamemory @ ! +! c@ c! 2@ 2! align aligned allot allocate here free resize
 syn keyword revaadrarith chars char+ cells cell+ cell cell- 2cell+ 2cell- 3cell+ 4cell+
-syn keyword revamemblks move fill 
+syn keyword revamemblks move fill
 
 " conditionals
-syn keyword revacond if else then =if >if <if <>if if0  ;; catch throw 
+syn keyword revacond if else then =if >if <if <>if if0  ;; catch throw
 
 " iterations
 syn keyword revaloop while repeat until again
@@ -66,18 +69,18 @@
 syn match revaColonDef '\<noname:\|\<:\s+' contains=revaComment
 syn keyword revaEndOfColonDef ; ;inline
 syn keyword revadefine constant constant, variable create variable,
-syn keyword revadefine user value to +to defer! defer@ defer is does> immediate 
+syn keyword revadefine user value to +to defer! defer@ defer is does> immediate
 syn keyword revadefine compile literal ' [']
 
 " Built in words
 com! -nargs=+ Builtin syn keyword revaBuiltin <args>
 Builtin execute ahead interp bye >body here pad words make
 Builtin accept close cr creat delete ekey emit fsize ioerr key?
-Builtin mtime open/r open/rw read rename seek space spaces stat 
+Builtin mtime open/r open/rw read rename seek space spaces stat
 Builtin tell type type_ write (seek) (argv) (save) 0; 0drop;
 Builtin >class >lz >name >xt alias alias: appname argc asciiz, asciizl,
 Builtin body> clamp depth disassemble findprev fnvhash getenv here,
-Builtin iterate last! last@ later link lz> lzmax os parse/ peek 
+Builtin iterate last! last@ later link lz> lzmax os parse/ peek
 Builtin peek-n pop prior push put rp@ rpick save setenv slurp
 Builtin stack-empty? stack-iterate stack-size stack: THROW_BADFUNC
 Builtin THROW_BADLIB THROW_GENERIC used xt>size z,
@@ -88,21 +91,21 @@
 Builtin (-lib) (bye) (call) (else) (find) (func) (here) (if (lib) (s0) (s^)
 Builtin (to~) (while) >in >rel ?literal appstart cold compiling? context? d0 default_class
 Builtin defer? dict dolstr dostr find-word h0 if) interp isa onexit
-Builtin onstartup pdoes pop>ebx prompt rel> rp0 s0 src srcstr state str0 then,> then> tib 
+Builtin onstartup pdoes pop>ebx prompt rel> rp0 s0 src srcstr state str0 then,> then> tib
 Builtin tp vector vector! word? xt? .ver revaver revaver# && '' 'constant 'context
 Builtin 'create 'defer 'does 'forth 'inline 'macro 'macront 'notail 'value 'variable
 Builtin (.r) (context) (create) (header) (hide) (inline) (p.r) (words~) (xfind)
 Builtin ++ -- , -2drop -2nip -link -swap . .2x .classes .contexts .funcs .libs .needs .r
 Builtin .rs .x 00; 0do 0if 1, 2, 3, 2* 2/ 2constant 2variable 3dup 4dup ;then >base >defer
 Builtin >rr ? ?do @execute @rem appdir argv as back base base! between chain cleanup-libs
-Builtin cmove> context?? ctrl-c ctx>name data: defer: defer@def dictgone do_cr eleave 
-Builtin endcase endof eval exception exec false find func: header heapgone help help/ 
+Builtin cmove> context?? ctrl-c ctx>name data: defer: defer@def dictgone do_cr eleave
+Builtin endcase endof eval exception exec false find func: header heapgone help help/
 Builtin hex# hide inline{ last lastxt lib libdir literal, makeexename mnotail ms ms@
-Builtin newclass noop nosavedict notail nul of off on p: padchar parse parseln 
-Builtin parsews rangeof rdepth remains reset reva revaused rol8 rr> scratch setclass sp 
+Builtin newclass noop nosavedict notail nul of off on p: padchar parse parseln
+Builtin parsews rangeof rdepth remains reset reva revaused rol8 rr> scratch setclass sp
 Builtin strof super> temp time&date true turnkey? undo vfunc: w! w@
 Builtin xchg xchg2 xfind xt>name xwords { {{ }} }  _+ _1+ _1- pathsep case \||
-" p[ [''] [ ['] 
+" p[ [''] [ [']
 
 
 " debugging
@@ -116,11 +119,11 @@
 " syn region revaCharOps start=+."\s+ skip=+\\"+ end=+"+
 
 " char-number conversion
-syn keyword revaconversion s>d >digit digit> >single >double >number >float 
+syn keyword revaconversion s>d >digit digit> >single >double >number >float
 
 " contexts
-syn keyword revavocs forth macro inline  
-syn keyword revavocs context: 
+syn keyword revavocs forth macro inline
+syn keyword revavocs context:
 syn match revavocs /\<\~[^~ ]*/
 syn match revavocs /[^~ ]*\~\>/
 
@@ -135,7 +138,7 @@
 
 " Strings
 " syn region revaString start=+\.\?\"+ end=+"+ end=+$+
-syn region revaString start=/"/ skip=/\\"/ end=/"/ 
+syn region revaString start=/"/ skip=/\\"/ end=/"/
 
 " Comments
 syn region revaComment start='\\S\s' end='.*' contains=revaTodo
@@ -187,5 +190,7 @@
 endif
 
 let b:current_syntax = "reva"
+let &cpo = s:cpo_save
+unlet s:cpo_save
 
 " vim: ts=8:sw=4:nocindent:smartindent:
