vahagn/scripts
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Improved config setup via install.sh

Browse Source
This commit is contained in:
Vahagn Khachatryan
2021-07-22 10:11:45 -07:00
parent b2d188344e
commit ea3717a930
11 changed files with 2814 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
config/.gdb/gdbinit Normal file
View File

@@ -0,0 +1,18 @@
set disassembly-flavor intel
set confirm off
#set follow-fork-mode child
#set detach-on-fork off
#
# C++ related beautifiers
#
set print pretty on
set print object on
#set print static-members on
set print vtbl on
set print demangle on
set demangle-style gnu-v3
set print sevenbit-strings off
source ~/devel/scripts/gdb/print_stl

680
config/.gdb/print_stl Normal file
View File

@@ -0,0 +1,680 @@
#
# STL GDB evaluators/views/utilities - 1.03
#
# The new GDB commands:
# are entirely non instrumental
# do not depend on any "inline"(s) - e.g. size(), [], etc
# are extremely tolerant to debugger settings
#
# This file should be "included" in .gdbinit as following:
# source stl-views.gdb or just paste it into your .gdbinit file
#
# The following STL containers are currently supported:
#
# std::vector<T> -- via pvector command
# std::list<T> -- via plist or plist_member command
# std::map<T,T> -- via pmap or pmap_member command
# std::multimap<T,T> -- via pmap or pmap_member command
# std::set<T> -- via pset command
# std::multiset<T> -- via pset command
# std::deque<T> -- via pdequeue command
# std::stack<T> -- via pstack command
# std::queue<T> -- via pqueue command
# std::priority_queue<T> -- via ppqueue command
# std::bitset<n> -- via pbitset command
# std::string -- via pstring command
# std::widestring -- via pwstring command
#
# The end of this file contains (optional) C++ beautifiers
# Make sure your debugger supports $argc
#
# Simple GDB Macros writen by Dan Marinescu (H-PhD) - License GPL
# Inspired by intial work of Tom Malnar,
# Tony Novac (PhD) / Cornell / Stanford,
# Gilad Mishne (PhD) and Many Many Others.
# Contact: dan_c_marinescu@yahoo.com (Subject: STL)
#
# Modified to work with g++ 4.3 by Anders Elton
# Also added _member functions, that instead of printing the entire class in map, prints a member.
#
# std::vector<>
#
define pvector
if $argc == 0
help pvector
else
set $size = $arg0._M_impl._M_finish - $arg0._M_impl._M_start
set $capacity = $arg0._M_impl._M_end_of_storage - $arg0._M_impl._M_start
set $size_max = $size - 1
end
if $argc == 1
set $i = 0
while $i < $size
printf "elem[%u]: ", $i
p *($arg0._M_impl._M_start + $i)
set $i++
end
end
if $argc == 2
set $idx = $arg1
if $idx < 0 || $idx > $size_max
printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max
else
printf "elem[%u]: ", $idx
p *($arg0._M_impl._M_start + $idx)
end
end
if $argc == 3
set $start_idx = $arg1
set $stop_idx = $arg2
if $start_idx > $stop_idx
set $tmp_idx = $start_idx
set $start_idx = $stop_idx
set $stop_idx = $tmp_idx
end
if $start_idx < 0 || $stop_idx < 0 || $start_idx > $size_max || $stop_idx > $size_max
printf "idx1, idx2 are not in acceptable range: [0..%u].\n", $size_max
else
set $i = $start_idx
while $i <= $stop_idx
printf "elem[%u]: ", $i
p *($arg0._M_impl._M_start + $i)
set $i++
end
end
end
if $argc > 0
printf "Vector size = %u\n", $size
printf "Vector capacity = %u\n", $capacity
printf "Element "
whatis $arg0._M_impl._M_start
end
end
document pvector
Prints std::vector<T> information.
Syntax: pvector <vector> <idx1> <idx2>
Note: idx, idx1 and idx2 must be in acceptable range [0..<vector>.size()-1].
Examples:
pvector v - Prints vector content, size, capacity and T typedef
pvector v 0 - Prints element[idx] from vector
pvector v 1 2 - Prints elements in range [idx1..idx2] from vector
end
#
# std::list<>
#
define plist
if $argc == 0
help plist
else
set $head = &$arg0._M_impl._M_node
set $current = $arg0._M_impl._M_node._M_next
set $size = 0
while $current != $head
if $argc == 2
printf "elem[%u]: ", $size
p *($arg1*)($current + 1)
end
if $argc == 3
if $size == $arg2
printf "elem[%u]: ", $size
p *($arg1*)($current + 1)
end
end
set $current = $current._M_next
set $size++
end
printf "List size = %u \n", $size
if $argc == 1
printf "List "
whatis $arg0
printf "Use plist <variable_name> <element_type> to see the elements in the list.\n"
end
end
end
document plist
Prints std::list<T> information.
Syntax: plist <list> <T> <idx>: Prints list size, if T defined all elements or just element at idx
Examples:
plist l - prints list size and definition
plist l int - prints all elements and list size
plist l int 2 - prints the third element in the list (if exists) and list size
end
define plist_member
if $argc == 0
help plist_member
else
set $head = &$arg0._M_impl._M_node
set $current = $arg0._M_impl._M_node._M_next
set $size = 0
while $current != $head
if $argc == 3
printf "elem[%u]: ", $size
p (*($arg1*)($current + 1)).$arg2
end
if $argc == 4
if $size == $arg3
printf "elem[%u]: ", $size
p (*($arg1*)($current + 1)).$arg2
end
end
set $current = $current._M_next
set $size++
end
printf "List size = %u \n", $size
if $argc == 1
printf "List "
whatis $arg0
printf "Use plist_member <variable_name> <element_type> <member> to see the elements in the list.\n"
end
end
end
document plist_member
Prints std::list<T> information.
Syntax: plist <list> <T> <idx>: Prints list size, if T defined all elements or just element at idx
Examples:
plist_member l int member - prints all elements and list size
plist_member l int member 2 - prints the third element in the list (if exists) and list size
end
#
# std::map and std::multimap
#
define pmap
if $argc == 0
help pmap
else
set $tree = $arg0
set $i = 0
set $node = $tree._M_t._M_impl._M_header._M_left
set $end = $tree._M_t._M_impl._M_header
set $tree_size = $tree._M_t._M_impl._M_node_count
if $argc == 1
printf "Map "
whatis $tree
printf "Use pmap <variable_name> <left_element_type> <right_element_type> to see the elements in the map.\n"
end
if $argc == 3
while $i < $tree_size
set $value = (void *)($node + 1)
printf "elem[%u].left: ", $i
p *($arg1*)$value
set $value = $value + sizeof($arg1)
printf "elem[%u].right: ", $i
p *($arg2*)$value
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
end
if $argc == 4
set $idx = $arg3
set $ElementsFound = 0
while $i < $tree_size
set $value = (void *)($node + 1)
if *($arg1*)$value == $idx
printf "elem[%u].left: ", $i
p *($arg1*)$value
set $value = $value + sizeof($arg1)
printf "elem[%u].right: ", $i
p *($arg2*)$value
set $ElementsFound++
end
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
printf "Number of elements found = %u\n", $ElementsFound
end
if $argc == 5
set $idx1 = $arg3
set $idx2 = $arg4
set $ElementsFound = 0
while $i < $tree_size
set $value = (void *)($node + 1)
set $valueLeft = *($arg1*)$value
set $valueRight = *($arg2*)($value + sizeof($arg1))
if $valueLeft == $idx1 && $valueRight == $idx2
printf "elem[%u].left: ", $i
p $valueLeft
printf "elem[%u].right: ", $i
p $valueRight
set $ElementsFound++
end
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
printf "Number of elements found = %u\n", $ElementsFound
end
printf "Map size = %u\n", $tree_size
end
end
document pmap
Prints std::map<TLeft and TRight> or std::multimap<TLeft and TRight> information. Works for std::multimap as well.
Syntax: pmap <map> <TtypeLeft> <TypeRight> <valLeft> <valRight>: Prints map size, if T defined all elements or just element(s) with val(s)
Examples:
pmap m - prints map size and definition
pmap m int int - prints all elements and map size
pmap m int int 20 - prints the element(s) with left-value = 20 (if any) and map size
pmap m int int 20 200 - prints the element(s) with left-value = 20 and right-value = 200 (if any) and map size
end
define pmap_member
if $argc == 0
help pmap_member
else
set $tree = $arg0
set $i = 0
set $node = $tree._M_t._M_impl._M_header._M_left
set $end = $tree._M_t._M_impl._M_header
set $tree_size = $tree._M_t._M_impl._M_node_count
if $argc == 1
printf "Map "
whatis $tree
printf "Use pmap <variable_name> <left_element_type> <right_element_type> to see the elements in the map.\n"
end
if $argc == 5
while $i < $tree_size
set $value = (void *)($node + 1)
printf "elem[%u].left: ", $i
p (*($arg1*)$value).$arg2
set $value = $value + sizeof($arg1)
printf "elem[%u].right: ", $i
p (*($arg3*)$value).$arg4
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
end
if $argc == 6
set $idx = $arg5
set $ElementsFound = 0
while $i < $tree_size
set $value = (void *)($node + 1)
if *($arg1*)$value == $idx
printf "elem[%u].left: ", $i
p (*($arg1*)$value).$arg2
set $value = $value + sizeof($arg1)
printf "elem[%u].right: ", $i
p (*($arg3*)$value).$arg4
set $ElementsFound++
end
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
printf "Number of elements found = %u\n", $ElementsFound
end
printf "Map size = %u\n", $tree_size
end
end
document pmap_member
Prints std::map<TLeft and TRight> or std::multimap<TLeft and TRight> information. Works for std::multimap as well.
Syntax: pmap <map> <TtypeLeft> <TypeRight> <valLeft> <valRight>: Prints map size, if T defined all elements or just element(s) with val(s)
Examples:
pmap_member m class1 member1 class2 member2 - prints class1.member1 : class2.member2
pmap_member m class1 member1 class2 member2 lvalue - prints class1.member1 : class2.member2 where class1 == lvalue
end
#
# std::set and std::multiset
#
define pset
if $argc == 0
help pset
else
set $tree = $arg0
set $i = 0
set $node = $tree._M_t._M_impl._M_header._M_left
set $end = $tree._M_t._M_impl._M_header
set $tree_size = $tree._M_t._M_impl._M_node_count
if $argc == 1
printf "Set "
whatis $tree
printf "Use pset <variable_name> <element_type> to see the elements in the set.\n"
end
if $argc == 2
while $i < $tree_size
set $value = (void *)($node + 1)
printf "elem[%u]: ", $i
p *($arg1*)$value
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
end
if $argc == 3
set $idx = $arg2
set $ElementsFound = 0
while $i < $tree_size
set $value = (void *)($node + 1)
if *($arg1*)$value == $idx
printf "elem[%u]: ", $i
p *($arg1*)$value
set $ElementsFound++
end
if $node._M_right != 0
set $node = $node._M_right
while $node._M_left != 0
set $node = $node._M_left
end
else
set $tmp_node = $node._M_parent
while $node == $tmp_node._M_right
set $node = $tmp_node
set $tmp_node = $tmp_node._M_parent
end
if $node._M_right != $tmp_node
set $node = $tmp_node
end
end
set $i++
end
printf "Number of elements found = %u\n", $ElementsFound
end
printf "Set size = %u\n", $tree_size
end
end
document pset
Prints std::set<T> or std::multiset<T> information. Works for std::multiset as well.
Syntax: pset <set> <T> <val>: Prints set size, if T defined all elements or just element(s) having val
Examples:
pset s - prints set size and definition
pset s int - prints all elements and the size of s
pset s int 20 - prints the element(s) with value = 20 (if any) and the size of s
end
#
# std::dequeue
#
define pdequeue
if $argc == 0
help pdequeue
else
set $size = 0
set $start_cur = $arg0._M_impl._M_start._M_cur
set $start_last = $arg0._M_impl._M_start._M_last
set $start_stop = $start_last
while $start_cur != $start_stop
p *$start_cur
set $start_cur++
set $size++
end
set $finish_first = $arg0._M_impl._M_finish._M_first
set $finish_cur = $arg0._M_impl._M_finish._M_cur
set $finish_last = $arg0._M_impl._M_finish._M_last
if $finish_cur < $finish_last
set $finish_stop = $finish_cur
else
set $finish_stop = $finish_last
end
while $finish_first != $finish_stop
p *$finish_first
set $finish_first++
set $size++
end
printf "Dequeue size = %u\n", $size
end
end
document pdequeue
Prints std::dequeue<T> information.
Syntax: pdequeue <dequeue>: Prints dequeue size, if T defined all elements
Deque elements are listed "left to right" (left-most stands for front and right-most stands for back)
Example:
pdequeue d - prints all elements and size of d
end
#
# std::stack
#
define pstack
if $argc == 0
help pstack
else
set $start_cur = $arg0.c._M_impl._M_start._M_cur
set $finish_cur = $arg0.c._M_impl._M_finish._M_cur
set $size = $finish_cur - $start_cur
set $i = $size - 1
while $i >= 0
p *($start_cur + $i)
set $i--
end
printf "Stack size = %u\n", $size
end
end
document pstack
Prints std::stack<T> information.
Syntax: pstack <stack>: Prints all elements and size of the stack
Stack elements are listed "top to buttom" (top-most element is the first to come on pop)
Example:
pstack s - prints all elements and the size of s
end
#
# std::queue
#
define pqueue
if $argc == 0
help pqueue
else
set $start_cur = $arg0.c._M_impl._M_start._M_cur
set $finish_cur = $arg0.c._M_impl._M_finish._M_cur
set $size = $finish_cur - $start_cur
set $i = 0
while $i < $size
p *($start_cur + $i)
set $i++
end
printf "Queue size = %u\n", $size
end
end
document pqueue
Prints std::queue<T> information.
Syntax: pqueue <queue>: Prints all elements and the size of the queue
Queue elements are listed "top to bottom" (top-most element is the first to come on pop)
Example:
pqueue q - prints all elements and the size of q
end
#
# std::priority_queue
#
define ppqueue
if $argc == 0
help ppqueue
else
set $size = $arg0.c._M_impl._M_finish - $arg0.c._M_impl._M_start
set $capacity = $arg0.c._M_impl._M_end_of_storage - $arg0.c._M_impl._M_start
set $i = $size - 1
while $i >= 0
p *($arg0.c._M_impl._M_start + $i)
set $i--
end
printf "Priority queue size = %u\n", $size
printf "Priority queue capacity = %u\n", $capacity
end
end
document ppqueue
Prints std::priority_queue<T> information.
Syntax: ppqueue <priority_queue>: Prints all elements, size and capacity of the priority_queue
Priority_queue elements are listed "top to buttom" (top-most element is the first to come on pop)
Example:
ppqueue pq - prints all elements, size and capacity of pq
end
#
# std::bitset
#
define pbitset
if $argc == 0
help pbitset
else
p /t $arg0._M_w
end
end
document pbitset
Prints std::bitset<n> information.
Syntax: pbitset <bitset>: Prints all bits in bitset
Example:
pbitset b - prints all bits in b
end
#
# std::string
#
define pstring
if $argc == 0
help pstring
else
printf "String \t\t\t= \"%s\"\n", $arg0._M_data()
printf "String size/length \t= %u\n", $arg0._M_rep()._M_length
printf "String capacity \t= %u\n", $arg0._M_rep()._M_capacity
printf "String ref-count \t= %d\n", $arg0._M_rep()._M_refcount
end
end
document pstring
Prints std::string information.
Syntax: pstring <string>
Example:
pstring s - Prints content, size/length, capacity and ref-count of string s
end
#
# std::wstring
#
define pwstring
if $argc == 0
help pwstring
else
call printf("WString \t\t= \"%ls\"\n", $arg0._M_data())
printf "WString size/length \t= %u\n", $arg0._M_rep()._M_length
printf "WString capacity \t= %u\n", $arg0._M_rep()._M_capacity
printf "WString ref-count \t= %d\n", $arg0._M_rep()._M_refcount
end
end
document pwstring
Prints std::wstring information.
Syntax: pwstring <wstring>
Example:
pwstring s - Prints content, size/length, capacity and ref-count of wstring s
end

47
config/.gdb/print_stl_test.cpp Normal file
View File

@@ -0,0 +1,47 @@
//VIM: let g:lcppflags="-g --std=c++0x"
//
#include <list>
#include <vector>
#include <map>
#include <set>
#include <deque>
#include <string>
int main()
{
std::vector<int> v;
v.push_back(10);
v.push_back(11);
v.push_back(12);
v.push_back(13);
std::vector<std::pair<int,int>> v2;
v2.push_back(std::make_pair(23,34));
v2.push_back(std::make_pair(3,4));
v2.push_back(std::make_pair(423,534));
std::list<std::pair<int,int>> l;
l.push_back(std::make_pair(23,34));
l.push_back(std::make_pair(3,4));
l.push_back(std::make_pair(423,534));
std::deque<std::pair<int,int>> q;
q.push_back(std::make_pair(23,34));
q.push_back(std::make_pair(3,4));
q.push_back(std::make_pair(423,534));
std::map<int,int> m;
m.insert(std::make_pair(23,34));
m.insert(std::make_pair(3,4));
m.insert(std::make_pair(423,534));
std::set<std::pair<int,int>> s;
s.insert(std::make_pair(23,34));
s.insert(std::make_pair(3,4));
s.insert(std::make_pair(423,534));
std::string str = "This is a string.";
break_here:
return 0;
}

2801
config/.vim/autoload/plug.vim Normal file
View File

File diff suppressed because it is too large Load Diff

52
config/.vim/colors/vahagn_black_terminal.vim Normal file
View File

@@ -0,0 +1,52 @@
" Vim color file
" First remove all existing highlighting.
set background=dark
hi clear
if exists("syntax_on")
syntax reset
endif
let colors_name = "vahagn_black_terminal"
hi Normal ctermbg=black ctermfg=White guifg=White guibg=grey20
" Groups used in the 'highlight' and 'guicursor' options default value.
hi ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White
hi IncSearch term=reverse cterm=reverse gui=reverse
hi ModeMsg term=bold cterm=bold gui=bold
hi StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold
hi StatusLineNC term=reverse cterm=reverse gui=reverse
hi VertSplit term=reverse cterm=reverse gui=reverse
hi Visual term=reverse ctermbg=DarkGray guibg=grey60
hi VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold
hi DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red
hi Cursor guibg=Green guifg=Black
hi lCursor guibg=Cyan guifg=Black
hi Directory term=bold ctermfg=LightCyan guifg=Cyan
hi LineNr term=underline ctermfg=Yellow guifg=Yellow
hi MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen
hi NonText term=bold ctermfg=LightBlue gui=bold guifg=LightBlue guibg=grey30
hi Question term=standout ctermfg=LightGreen gui=bold guifg=Green
hi Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black
hi SpecialKey term=bold ctermfg=LightBlue guifg=Cyan
hi Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta
hi WarningMsg term=standout ctermfg=LightRed guifg=Red
hi WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black
hi Folded term=standout ctermbg=LightGrey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue
hi FoldColumn term=standout ctermbg=LightGrey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue
hi DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue
hi DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta
hi DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan
hi CursorColumn term=reverse ctermbg=Black guibg=grey40
hi CursorLine term=underline cterm=underline guibg=grey40
" Groups for syntax highlighting
hi Constant term=underline ctermfg=Magenta guifg=#ffa0a0 guibg=grey5
hi Special term=bold ctermfg=LightRed guifg=Orange guibg=grey5
if &t_Co > 8
hi Statement term=bold cterm=bold ctermfg=Yellow guifg=#ffff60 gui=bold
endif
hi Ignore ctermfg=DarkGrey guifg=grey20
" vim: sw=2

70
config/.vim/plugin/local-vimrc.vim Normal file
View File

@@ -0,0 +1,70 @@
"
" Authors: Vahagn Khachatryan (vahagn DOT khachatryan AT gmail DOT com)
"
" Licence: http://www.opensource.org/licenses/mit-license.php
" The MIT License
"
" This file is based on Andy Dawson's independence.vim
"
"-----------------------------------------------------------------------------
"
" Section: Documentation
"
" The vim local-vimrc plugin loads a .vimrc file from upper directories if
" it exists. This allows you to override your vim settings on a directory tree
" basis.
" Section: Plugin header
"
" loaded_local_vimrc is set to 1 when initialization begins, and 2 when it
" completes.
if exists('g:loaded_local_vimrc')
finish
endif
let g:loaded_local_vimrc=1
" Section: Event group setup
" Act when creating or loading a file
augroup LocalVimrc
au BufNewFile,BufRead * call s:LocalVimrcLoadForFile()
augroup END
" Function: LoadConfig()
"
" If the file .vimrc exists in the path - load it
function s:LocalVimrcLoadForFile()
let l:path = fnameescape(expand("%:p:h"))
call g:LocalVimrcLoad( l:path )
endfunction
" Function: LocalVimrcLoad()
"
" If the file .vimrc exists in the path - load it
function! g:LocalVimrcLoad(path)
let l:path = a:path
if empty(l:path)
return
endif
let l:paths = []
let l:pathp = ""
while l:pathp != l:path
let l:vimrc = l:path.'/.vimrc.local'
if filereadable(l:vimrc) && l:vimrc != $MYVIMRC
let l:paths = [ l:vimrc ] + l:paths
endif
"echo 'try'.l:path
let l:pathp = l:path
let l:path = fnamemodify(l:path, ":h")
endwhile
"echo l:paths
for vimrc in l:paths
exec ":source " . vimrc
endfor
endfunction
" Section: Plugin completion
let g:loaded_local_vimrc=2

1
config/.vim/spell/en.utf-8.add Normal file
View File

@@ -0,0 +1 @@
mv

BIN
config/.vim/spell/en.utf-8.add.spl Normal file
View File

Binary file not shown.

569
config/.vim/syntax/calibre.vim Normal file
View File

@@ -0,0 +1,569 @@
" Vim syntax file
" Language: Calibre
" Maintainer: Mentor Graphics Corp.
" Last change: August 5, 2010
" Extensions: *.drc,*.lvs,*.rul,*.rules
" Comment: This file includes SVRF/TVF Technology under license by Mentor Graphics Corporation. "SVRF/TVF Technology" shall mean Mentor Graphics' Standard Verification Rule Format ("SVRF") and Tcl Verification Format ("TVF ") proprietary syntaxes for expressing process rules. You shall not use SVRF/TVF Technology unless you are a Mentor Graphics customer as defined by having authorized access to Mentor Graphics' password protected support site at http://supportnet.mentor.com/. The exact terms of your obligations and rights are governed by your respective license. You shall not use SVRF/TVF Technology except: (a) for your internal business purposes and (b) for use with Mentor Graphics' Calibre(r) tools. All SVRF/TVF Technology constitutes or contains trade secrets and confidential information of Mentor Graphics or its licensors. You shall not make SVRF/TVF Technology available in any form to any person other than your employees and on-site contractors, excluding Mentor Graphics competitors, whose job performance requires access and who are under obligations of confidentiality.
"Version: 0.9 copied the command dictionary from SVRF manual version 2010.2
" 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
" Ignore case
syn case ignore
" A bunch of useful Calibre keywords
"Updated with keyword list from 2010.2
syn keyword calibreKeyword and angle area attach connect copy cut dbclassify deangle density device disconnect donut enclose enclosure extent extents external flatten group grow hcell holes include inside interact internal layer length magnify mdpmerge mdpstat mdpverify merge net not offgrid opcbias opclineend opcsbar or ornet outside pathchk perimeter pins polygon ports precision push rectangle rectangles resolution rotate sconnect shift shrink size snap stamp tddrc text title topex touch variable vertex xor trapezoider vboasis_injection speed_mode computation_mode <SVRFSTART> <SVRFEND> fracture_units vboasis_path log_file_name file_name svrf_layer_name version chip_directory input_region_severity cell_subfield_size cell_subfield_margin cell_max_width cell_max_height frame_width frame_max_data common_max_data conversion_address_unit max_skew_approximation_error svrf_layer_name shot_size cell_size_x cell_size_y field_size lsb1 format_type small_value
syn match calibreDirective "\#define "
syn match calibreKeyword "capacitance[\ \t][\ \t]*order[\ \t][\ \t]*"
syn match calibreKeyword "coincident[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "coincident[\ \t][\ \t]*inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "coincident[\ \t][\ \t]*outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "convex[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "density[\ \t][\ \t]*convolve[\ \t][\ \t]*"
syn match calibreKeyword "device[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*analyze[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*connectivity[\ \t][\ \t]*redundant[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*copy[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*create[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*critical[\ \t][\ \t]*area[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*database[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*defaults[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*expand[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*expand[\ \t][\ \t]*enclosure[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*fill[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*function[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*grow[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*histogram[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*measure[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*narac[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*property[\ \t][\ \t]*merge[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*rdb[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*read[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*redundant[\ \t][\ \t]*vias[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*select[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*shift[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*size[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*space[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*spec[\ \t][\ \t]*fill[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*spec[\ \t][\ \t]*fill[\ \t][\ \t]*optimizer[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*spec[\ \t][\ \t]*fill[\ \t][\ \t]*shape[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*spec[\ \t][\ \t]*spatial[\ \t][\ \t]*sample[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*spec[\ \t][\ \t]*via[\ \t][\ \t]*redundancy[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*stamp[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*transform[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*transition[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*unselect[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "dfm[\ \t][\ \t]*ys[\ \t][\ \t]*autostart[\ \t][\ \t]*"
syn match calibreKeyword "drawn[\ \t][\ \t]*acute[\ \t][\ \t]*"
syn match calibreKeyword "drawn[\ \t][\ \t]*angled[\ \t][\ \t]*"
syn match calibreKeyword "drawn[\ \t][\ \t]*offgrid[\ \t][\ \t]*"
syn match calibreKeyword "drawn[\ \t][\ \t]*skew[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*cell[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*cell[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*check[\ \t][\ \t]*map[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*check[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*exclude[\ \t][\ \t]*false[\ \t][\ \t]*notch[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*icstation[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*incremental[\ \t][\ \t]*connect[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*incremental[\ \t][\ \t]*connect[\ \t][\ \t]*warning[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*keep[\ \t][\ \t]*empty[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*magnify[\ \t][\ \t]*density[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*magnify[\ \t][\ \t]*nar[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*magnify[\ \t][\ \t]*results[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*map[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*map[\ \t][\ \t]*text[\ \t][\ \t]*depth[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*map[\ \t][\ \t]*text[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*maximum[\ \t][\ \t]*cell[\ \t][\ \t]*name[\ \t][\ \t]*length[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*maximum[\ \t][\ \t]*results[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*maximum[\ \t][\ \t]*unattached[\ \t][\ \t]*label[\ \t][\ \t]*warnings[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*maximum[\ \t][\ \t]*vertex[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*print[\ \t][\ \t]*area[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*print[\ \t][\ \t]*perimeter[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*results[\ \t][\ \t]*database[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*results[\ \t][\ \t]*database[\ \t][\ \t]*libname[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*results[\ \t][\ \t]*database[\ \t][\ \t]*precision[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*select[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*select[\ \t][\ \t]*check[\ \t][\ \t]*by[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*summary[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*tolerance[\ \t][\ \t]*factor[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*tolerance[\ \t][\ \t]*factor[\ \t][\ \t]*nar[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*unselect[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "drc[\ \t][\ \t]*unselect[\ \t][\ \t]*check[\ \t][\ \t]*by[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "enclose[\ \t][\ \t]*rectangle[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*cell[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*check[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*keep[\ \t][\ \t]*empty[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*maximum[\ \t][\ \t]*results[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*maximum[\ \t][\ \t]*vertex[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*path[\ \t][\ \t]*also[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*pathchk[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*results[\ \t][\ \t]*database[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*select[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*summary[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "erc[\ \t][\ \t]*unselect[\ \t][\ \t]*check[\ \t][\ \t]*"
syn match calibreKeyword "exclude[\ \t][\ \t]*acute[\ \t][\ \t]*"
syn match calibreKeyword "exclude[\ \t][\ \t]*angled[\ \t][\ \t]*"
syn match calibreKeyword "exclude[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "exclude[\ \t][\ \t]*offgrid[\ \t][\ \t]*"
syn match calibreKeyword "exclude[\ \t][\ \t]*skew[\ \t][\ \t]*"
syn match calibreKeyword "expand[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "expand[\ \t][\ \t]*cell[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "expand[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "expand[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "extent[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "extent[\ \t][\ \t]*drawn[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*acute[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*angled[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*nonsimple[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*nonsimple[\ \t][\ \t]*path[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*offgrid[\ \t][\ \t]*"
syn match calibreKeyword "flag[\ \t][\ \t]*skew[\ \t][\ \t]*"
syn match calibreKeyword "flatten[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "flatten[\ \t][\ \t]*inside[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*hitachi[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*jeol[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*mebes[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*micronic[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*nuflare[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*vboasis[\ \t][\ \t]*"
syn match calibreKeyword "fracture[\ \t][\ \t]*oasis_mask[\ \t][\ \t]*"
syn match calibreKeyword "inductance[\ \t][\ \t]*micheck[\ \t][\ \t]*"
syn match calibreKeyword "inductance[\ \t][\ \t]*wire[\ \t][\ \t]*"
syn match calibreKeyword "inside[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "label[\ \t][\ \t]*order[\ \t][\ \t]*"
syn match calibreKeyword "layer[\ \t][\ \t]*directory[\ \t][\ \t]*"
syn match calibreKeyword "layer[\ \t][\ \t]*map[\ \t][\ \t]*"
syn match calibreKeyword "layer[\ \t][\ \t]*resolution[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*allow[\ \t][\ \t]*duplicate[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*base[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*base[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*bump2[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*case[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*cell[\ \t][\ \t]*list[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*cell[\ \t][\ \t]*match[\ \t][\ \t]*rule[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*depth[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*error[\ \t][\ \t]*on[\ \t][\ \t]*input[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*ignore[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*input[\ \t][\ \t]*exception[\ \t][\ \t]*rdb[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*input[\ \t][\ \t]*exception[\ \t][\ \t]*severity[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*magnify[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*merge[\ \t][\ \t]*on[\ \t][\ \t]*input[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*path[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*path2[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*place[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*polygon[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*precision[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*preserve[\ \t][\ \t]*case[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*preserve[\ \t][\ \t]*cell[\ \t][\ \t]*list[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*primary[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*primary2[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*process[\ \t][\ \t]*box[\ \t][\ \t]*record[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*process[\ \t][\ \t]*node[\ \t][\ \t]*record[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*property[\ \t][\ \t]*audit[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*property[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*rename[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*rename[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*system[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*system2[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*top[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*use[\ \t][\ \t]*database[\ \t][\ \t]*precision[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*windel[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*windel[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*windel[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*window[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*window[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*window[\ \t][\ \t]*clip[\ \t][\ \t]*"
syn match calibreKeyword "layout[\ \t][\ \t]*window[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*denseopc[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*opc[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*opcverify[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*orc[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*printimage[\ \t][\ \t]*"
syn match calibreKeyword "litho[\ \t][\ \t]*psmgate[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*abort[\ \t][\ \t]*on[\ \t][\ \t]*erc[\ \t][\ \t]*error[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*abort[\ \t][\ \t]*on[\ \t][\ \t]*softchk[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*abort[\ \t][\ \t]*on[\ \t][\ \t]*supply[\ \t][\ \t]*error[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*all[\ \t][\ \t]*capacitor[\ \t][\ \t]*pins[\ \t][\ \t]*swappable[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*auto[\ \t][\ \t]*expand[\ \t][\ \t]*hcells[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*box[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*builtin[\ \t][\ \t]*device[\ \t][\ \t]*pin[\ \t][\ \t]*swap[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*builtin[\ \t][\ \t]*mos[\ \t][\ \t]*nrd_nrs[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*cell[\ \t][\ \t]*list[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*cell[\ \t][\ \t]*supply[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*center[\ \t][\ \t]*device[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*check[\ \t][\ \t]*port[\ \t][\ \t]*names[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*compare[\ \t][\ \t]*case[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*component[\ \t][\ \t]*subtype[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*component[\ \t][\ \t]*type[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*cpoint[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*device[\ \t][\ \t]*type[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*discard[\ \t][\ \t]*pins[\ \t][\ \t]*by[\ \t][\ \t]*device[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*downcase[\ \t][\ \t]*device[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*eddm[\ \t][\ \t]*process[\ \t][\ \t]*m[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*exact[\ \t][\ \t]*subtypes[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*exclude[\ \t][\ \t]*hcell[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*execute[\ \t][\ \t]*erc[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*expand[\ \t][\ \t]*seed[\ \t][\ \t]*promotions[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*expand[\ \t][\ \t]*unbalanced[\ \t][\ \t]*cells[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*bipolar[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*capacitors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*diodes[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*mos[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*option[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*filter[\ \t][\ \t]*unused[\ \t][\ \t]*resistors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*global[\ \t][\ \t]*layout[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*globals[\ \t][\ \t]*are[\ \t][\ \t]*ports[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*ground[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*heap[\ \t][\ \t]*directory[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*ignore[\ \t][\ \t]*ports[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*ignore[\ \t][\ \t]*trivial[\ \t][\ \t]*named[\ \t][\ \t]*ports[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*inject[\ \t][\ \t]*logic[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*isolate[\ \t][\ \t]*shorts[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*map[\ \t][\ \t]*device[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*all[\ \t][\ \t]*texted[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*allow[\ \t][\ \t]*inconsistent[\ \t][\ \t]*model[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*box[\ \t][\ \t]*contents[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*comment[\ \t][\ \t]*coded[\ \t][\ \t]*properties[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*comment[\ \t][\ \t]*coded[\ \t][\ \t]*substrate[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*netlist[\ \t][\ \t]*unnamed[\ \t][\ \t]*box[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*nl[\ \t][\ \t]*pin[\ \t][\ \t]*locations[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*non[\ \t][\ \t]*user[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*out[\ \t][\ \t]*of[\ \t][\ \t]*range[\ \t][\ \t]*exclude[\ \t][\ \t]*zero[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*pin[\ \t][\ \t]*name[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*power[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*precise[\ \t][\ \t]*interaction[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*preserve[\ \t][\ \t]*box[\ \t][\ \t]*cells[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*preserve[\ \t][\ \t]*box[\ \t][\ \t]*ports[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*preserve[\ \t][\ \t]*floating[\ \t][\ \t]*top[\ \t][\ \t]*nets[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*preserve[\ \t][\ \t]*parameterized[\ \t][\ \t]*cells[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*property[\ \t][\ \t]*initialize[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*property[\ \t][\ \t]*map[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*property[\ \t][\ \t]*resolution[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*push[\ \t][\ \t]*devices[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*recognize[\ \t][\ \t]*gates[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*recognize[\ \t][\ \t]*gates[\ \t][\ \t]*tolerance[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*parallel[\ \t][\ \t]*bipolar[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*parallel[\ \t][\ \t]*capacitors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*parallel[\ \t][\ \t]*diodes[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*parallel[\ \t][\ \t]*mos[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*parallel[\ \t][\ \t]*resistors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*semi[\ \t][\ \t]*series[\ \t][\ \t]*mos[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*series[\ \t][\ \t]*capacitors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*series[\ \t][\ \t]*mos[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*series[\ \t][\ \t]*resistors[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduce[\ \t][\ \t]*split[\ \t][\ \t]*gates[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reduction[\ \t][\ \t]*priority[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*option[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*units[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*warnings[\ \t][\ \t]*hcell[\ \t][\ \t]*only[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*report[\ \t][\ \t]*warnings[\ \t][\ \t]*top[\ \t][\ \t]*only[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*reverse[\ \t][\ \t]*wl[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*short[\ \t][\ \t]*equivalent[\ \t][\ \t]*nodes[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*show[\ \t][\ \t]*seed[\ \t][\ \t]*promotions[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*show[\ \t][\ \t]*seed[\ \t][\ \t]*promotions[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*signature[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*soft[\ \t][\ \t]*substrate[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*softchk[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*allow[\ \t][\ \t]*duplicate[\ \t][\ \t]*subcircuit[\ \t][\ \t]*names[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*allow[\ \t][\ \t]*floating[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*allow[\ \t][\ \t]*inline[\ \t][\ \t]*parameters[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*allow[\ \t][\ \t]*unquoted[\ \t][\ \t]*strings[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*conditional[\ \t][\ \t]*ldd[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*cull[\ \t][\ \t]*primitive[\ \t][\ \t]*subcircuits[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*implied[\ \t][\ \t]*mos[\ \t][\ \t]*area[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*multiplier[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*option[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*override[\ \t][\ \t]*globals[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*prefer[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*redefine[\ \t][\ \t]*param[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*rename[\ \t][\ \t]*parameter[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*replicate[\ \t][\ \t]*devices[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*scale[\ \t][\ \t]*x[\ \t][\ \t]*parameters[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*slash[\ \t][\ \t]*is[\ \t][\ \t]*space[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*spice[\ \t][\ \t]*strict[\ \t][\ \t]*wl[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*split[\ \t][\ \t]*gate[\ \t][\ \t]*ratio[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*strict[\ \t][\ \t]*subtypes[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*summary[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*write[\ \t][\ \t]*injected[\ \t][\ \t]*layout[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*write[\ \t][\ \t]*injected[\ \t][\ \t]*source[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*write[\ \t][\ \t]*layout[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "lvs[\ \t][\ \t]*write[\ \t][\ \t]*source[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "mask[\ \t][\ \t]*results[\ \t][\ \t]*database[\ \t][\ \t]*"
syn match calibreKeyword "mask[\ \t][\ \t]*svdb[\ \t][\ \t]*directory[\ \t][\ \t]*"
syn match calibreKeyword "mdp[\ \t][\ \t]*checkmap[\ \t][\ \t]*"
syn match calibreKeyword "mdp[\ \t][\ \t]*embed[\ \t][\ \t]*"
syn match calibreKeyword "mdp[\ \t][\ \t]*mapsize[\ \t][\ \t]*"
syn match calibreKeyword "mdp[\ \t][\ \t]*maskopt[\ \t][\ \t]*"
syn match calibreKeyword "mdp[\ \t][\ \t]*oasis_extent[\ \t][\ \t]*"
syn match calibreKeyword "net[\ \t][\ \t]*area[\ \t][\ \t]*"
syn match calibreKeyword "net[\ \t][\ \t]*area[\ \t][\ \t]*ratio[\ \t][\ \t]*"
syn match calibreKeyword "net[\ \t][\ \t]*area[\ \t][\ \t]*ratio[\ \t][\ \t]*accumulate[\ \t][\ \t]*"
syn match calibreKeyword "net[\ \t][\ \t]*area[\ \t][\ \t]*ratio[\ \t][\ \t]*print[\ \t][\ \t]*"
syn match calibreKeyword "net[\ \t][\ \t]*interact[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*angle[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*area[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*coincident[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*coincident[\ \t][\ \t]*inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*coincident[\ \t][\ \t]*outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*cut[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*donut[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*enclose[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*enclose[\ \t][\ \t]*rectangle[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*inside[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*inside[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*interact[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*length[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*net[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*outside[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*rectangle[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*touch[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*touch[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*touch[\ \t][\ \t]*inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*touch[\ \t][\ \t]*outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*with[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*with[\ \t][\ \t]*neighbor[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*with[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "not[\ \t][\ \t]*with[\ \t][\ \t]*width[\ \t][\ \t]*"
syn match calibreKeyword "or[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "parasitic[\ \t][\ \t]*variation[\ \t][\ \t]*"
syn match calibreKeyword "path[\ \t][\ \t]*length[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*load[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*report[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*report[\ \t][\ \t]*option[\ \t][\ \t]*"
syn match calibreKeyword "perc[\ \t][\ \t]*report[\ \t][\ \t]*placement[\ \t][\ \t]*list[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*alias[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ba[\ \t][\ \t]*mapfile[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*bulk[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*cmp[\ \t][\ \t]*mode[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*contact[\ \t][\ \t]*capacitance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*corner[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*corner[\ \t][\ \t]*custom[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*def[\ \t][\ \t]*extract[\ \t][\ \t]*cell[\ \t][\ \t]*obstructions[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*density[\ \t][\ \t]*estimate[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*density[\ \t][\ \t]*window[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*driver[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*elayer[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*exclude[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*exclude[\ \t][\ \t]*lumped[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*extract[\ \t][\ \t]*exclude[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*extract[\ \t][\ \t]*floating[\ \t][\ \t]*nets[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*extract[\ \t][\ \t]*include[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*extract[\ \t][\ \t]*rgate[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*extract[\ \t][\ \t]*temperature[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*fieldsolver[\ \t][\ \t]*endcap[\ \t][\ \t]*spacing[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*fieldsolver[\ \t][\ \t]*mode[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*fill[\ \t][\ \t]*handling[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*fill[\ \t][\ \t]*model[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*fracture[\ \t][\ \t]*frequency[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*generate[\ \t][\ \t]*driver[\ \t][\ \t]*file[\ \t][\ \t]*tag[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*generate[\ \t][\ \t]*driver_file[\ \t][\ \t]*tag[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ground[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ground[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ideal[\ \t][\ \t]*xcell[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ignore[\ \t][\ \t]*capacitance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*ignore[\ \t][\ \t]*resistance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*include[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*include[\ \t][\ \t]*lumped[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*indie[\ \t][\ \t]*spacing[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*default[\ \t][\ \t]*partial[\ \t][\ \t]*model[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*default[\ \t][\ \t]*pi[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*differential[\ \t][\ \t]*pair[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*doprocess[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*driver[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*extract[\ \t][\ \t]*layers[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*filter[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*forward[\ \t][\ \t]*coupling[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*frequency[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*...[\ \t][\ \t]*frequency[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*micheck[\ \t][\ \t]*constraint[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*minlength[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*parameters[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*range[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*returnpath[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*same[\ \t][\ \t]*net[\ \t][\ \t]*mutual[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*self[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*skin[\ \t][\ \t]*include[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*switch[\ \t][\ \t]*time[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*switch_time[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*...[\ \t][\ \t]*switch[\ \t][\ \t]*time[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*...[\ \t][\ \t]*switch_time[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*victim[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*victim[\ \t][\ \t]*path[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*victim_path[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*victim[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*inductance[\ \t][\ \t]*victim_file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*magnify[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*adms[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*character[\ \t][\ \t]*map[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*connection[\ \t][\ \t]*section[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*create[\ \t][\ \t]*smashed[\ \t][\ \t]*device[\ \t][\ \t]*names[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*device[\ \t][\ \t]*resistance[\ \t][\ \t]*model[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*escape[\ \t][\ \t]*characters[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*global[\ \t][\ \t]*nets[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*lumped[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*mutual[\ \t][\ \t]*resistance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*noxref[\ \t][\ \t]*net[\ \t][\ \t]*names[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*position[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*replicated_device[\ \t][\ \t]*delimiter[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*schematiconly[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*select[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*simple[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*smashed_device[\ \t][\ \t]*delimiter[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*subnode[\ \t][\ \t]*section[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*unshort[\ \t][\ \t]*device[\ \t][\ \t]*pins[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*uppercase[\ \t][\ \t]*keywords[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*netlist[\ \t][\ \t]*virtual[\ \t][\ \t]*connect[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*pin[\ \t][\ \t]*order[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*power[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*probe[\ \t][\ \t]*file[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*analog[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*cc[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*digital[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*mincap[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*minres[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*ronly[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*ticer[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*reduce[\ \t][\ \t]*via[\ \t][\ \t]*resistance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*coupling[\ \t][\ \t]*capacitance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*lumped[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*mutual[\ \t][\ \t]*inductance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*netsummary[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*report[\ \t][\ \t]*point2point[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*resistance[\ \t][\ \t]*parameters[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*sensitivity[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*skin[\ \t][\ \t]*include[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*slots[\ \t][\ \t]*handling[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*temperature[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*thickness[\ \t][\ \t]*eqn[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*thickness[\ \t][\ \t]*nominal[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*threshold[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*tolerance[\ \t][\ \t]*distributed[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*via[\ \t][\ \t]*capacitance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*via[\ \t][\ \t]*reduction[\ \t][\ \t]*resistance[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*xcell[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*xcell[\ \t][\ \t]*extract[\ \t][\ \t]*mode[\ \t][\ \t]*"
syn match calibreKeyword "pex[\ \t][\ \t]*xcell[\ \t][\ \t]*precedence[\ \t][\ \t]*"
syn match calibreKeyword "port[\ \t][\ \t]*depth[\ \t][\ \t]*"
syn match calibreKeyword "port[\ \t][\ \t]*layer[\ \t][\ \t]*polygon[\ \t][\ \t]*"
syn match calibreKeyword "port[\ \t][\ \t]*layer[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "push[\ \t][\ \t]*cell[\ \t][\ \t]*"
syn match calibreKeyword "rectangle[\ \t][\ \t]*enclosure[\ \t][\ \t]*"
syn match calibreKeyword "resistance[\ \t][\ \t]*connection[\ \t][\ \t]*"
syn match calibreKeyword "resistance[\ \t][\ \t]*device_seed[\ \t][\ \t]*"
syn match calibreKeyword "resistance[\ \t][\ \t]*rho[\ \t][\ \t]*"
syn match calibreKeyword "resistance[\ \t][\ \t]*sheet[\ \t][\ \t]*"
syn match calibreKeyword "snap[\ \t][\ \t]*offgrid[\ \t][\ \t]*"
syn match calibreKeyword "source[\ \t][\ \t]*case[\ \t][\ \t]*"
syn match calibreKeyword "source[\ \t][\ \t]*path[\ \t][\ \t]*"
syn match calibreKeyword "source[\ \t][\ \t]*primary[\ \t][\ \t]*"
syn match calibreKeyword "source[\ \t][\ \t]*system[\ \t][\ \t]*"
syn match calibreKeyword "svrf[\ \t][\ \t]*error[\ \t][\ \t]*"
syn match calibreKeyword "svrf[\ \t][\ \t]*message[\ \t][\ \t]*"
syn match calibreKeyword "svrf[\ \t][\ \t]*version[\ \t][\ \t]*"
syn match calibreKeyword "text[\ \t][\ \t]*depth[\ \t][\ \t]*"
syn match calibreKeyword "text[\ \t][\ \t]*layer[\ \t][\ \t]*"
syn match calibreKeyword "text[\ \t][\ \t]*print[\ \t][\ \t]*maximum[\ \t][\ \t]*"
syn match calibreKeyword "touch[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "touch[\ \t][\ \t]*inside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "touch[\ \t][\ \t]*outside[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "trace[\ \t][\ \t]*property[\ \t][\ \t]*"
syn match calibreKeyword "unit[\ \t][\ \t]*capacitance[\ \t][\ \t]*"
syn match calibreKeyword "unit[\ \t][\ \t]*inductance[\ \t][\ \t]*"
syn match calibreKeyword "unit[\ \t][\ \t]*length[\ \t][\ \t]*"
syn match calibreKeyword "unit[\ \t][\ \t]*resistance[\ \t][\ \t]*"
syn match calibreKeyword "unit[\ \t][\ \t]*time[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*box[\ \t][\ \t]*colon[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*box[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*colon[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*depth[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*name[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*report[\ \t][\ \t]*"
syn match calibreKeyword "virtual[\ \t][\ \t]*connect[\ \t][\ \t]*semicolon[\ \t][\ \t]*as[\ \t][\ \t]*colon[\ \t][\ \t]*"
syn match calibreKeyword "with[\ \t][\ \t]*edge[\ \t][\ \t]*"
syn match calibreKeyword "with[\ \t][\ \t]*neighbor[\ \t][\ \t]*"
syn match calibreKeyword "with[\ \t][\ \t]*text[\ \t][\ \t]*"
syn match calibreKeyword "with[\ \t][\ \t]*width[\ \t][\ \t]*"
syn match calibreComment "//.*"
syn match calibreSpecialComment "@.*"
syn region calibreBlockComment start="/\*" end="\*/"
syn match calibreRuleName "[^//].*{"he=e-1
"Match Stings
"syn match calibreString /"[^"]*"/hs=s+1,he=e-1
syn match calibreString /"[^"]*"/
" Numbers, all with engineering suffixes and optional units
"==========================================================
"floating point number, with dot, optional exponent
syn match calibreNumber "\<[0-9]\+\.[0-9]*\(e[-+]\=[0-9]\+\)\=\(meg\=\|[afpnumkg]\)\="
"floating point number, starting with a dot, optional exponent
syn match calibreNumber "\.[0-9]\+\(e[-+]\=[0-9]\+\)\=\(meg\=\|[afpnumkg]\)\="
"integer number with optional exponent
syn match calibreNumber "\<[0-9]\+\(e[-+]\=[0-9]\+\)\=\(meg\=\|[afpnumkg]\)\="
"syn match calibrePreProc "^#.*"
syn match calibrePreProc "#.*"
"Modify the following as needed. The trade-off is performance versus
"functionality.
syn sync lines=50
" Define the default highlighting.
" For version 5.7 and earlier: only when not done already
" For version 5.8 and later: only when an item doesn't have highlighting yet
if version >= 508 || !exists("did_calibre_syn_inits")
if version < 508
let did_calibre_syn_inits = 1
command -nargs=+ HiLink hi link <args>
else
command -nargs=+ HiLink hi def link <args>
endif
HiLink calibreIdentifier Identifier
HiLink calibreStatement Statement
HiLink calibreKeyword Statement
HiLink calibreComment Comment
HiLink calibreBlockComment Comment
HiLink calibreSpecialComment SpecialComment
HiLink calibrePreProc PreProc
HiLink calibreString String
HiLink calibreNumber Number
HiLink calibreRuleName Structure
HiLink calibreDirective Question
delcommand HiLink
endif
let b:current_syntax = "calibre"
" vim: ts=8