1803 lines
80 KiB
Plaintext
1803 lines
80 KiB
Plaintext
# suppress_welcome true
|
|
|
|
logfile ~/.diakonos/diakonos.log
|
|
|
|
# session.default_session default-session
|
|
|
|
# mouse false
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Colour Definitions
|
|
#
|
|
# colour <integer greater than 7> <foreground colour> <background colour>
|
|
#
|
|
# For a list of colour names, see the list of format codes in the
|
|
# Language Definitions section, below.
|
|
#
|
|
# With this colour command you can set a different background colour than the
|
|
# terminal default.
|
|
#
|
|
# color is a synonym for colour.
|
|
colour 8 white blue
|
|
colour 9 white red
|
|
colour 10 white magenta
|
|
colour 11 yellow blue
|
|
colour 12 white green
|
|
colour 13 white brown
|
|
colour 14 black cyan
|
|
colour 15 yellow red
|
|
|
|
# Default background colour is whatever the terminal is set to (including
|
|
# transparency, if supported).
|
|
# Black is 0. Greyscale goes from 232 (dark grey) to 255 (white).
|
|
|
|
# colour.background 250
|
|
|
|
# When the cursor is view.margin.y lines or less from the top or
|
|
# bottom line, repeatedly scroll the screen view.jump.y lines until
|
|
# the cursor is more than view.margin.y lines from the top and
|
|
# bottom line.
|
|
# Similarly for view.margin.x and view.jump.x, with respect to the
|
|
# left-most and right-most screen columns.
|
|
view.margin.x 10
|
|
view.margin.y 5
|
|
view.jump.x 10
|
|
view.jump.y 5
|
|
view.scroll_amount 1
|
|
view.lookback 200
|
|
view.nonfilelines.visible false
|
|
view.nonfilelines.character ~
|
|
view.wrap.visual true
|
|
|
|
view.pairs.highlight true
|
|
|
|
view.line_numbers false
|
|
view.line_numbers.width 4
|
|
# view.line_numbers.number_format is a "printf" style format string
|
|
view.line_numbers.number_format "%3s "
|
|
view.line_numbers.format white
|
|
|
|
#view.column_markers.margin.column 80
|
|
view.column_markers.margin.format 9
|
|
|
|
view.non_search_area.format black
|
|
|
|
# bol_behaviour: This specifies where the cursor should go when the
|
|
# beginning-of-line key (the default is the Home key) is pressed.
|
|
# zero: Always move to the left-most column of the line
|
|
# first-char: Always move to the left-most non-whitespace character
|
|
# alternating-zero: As with 'zero', unless the cursor is
|
|
# already there, in which case, as with 'first-char'.
|
|
# alternating-first-char: As with 'first-char', unless the cursor is
|
|
# already there, in which case, as with 'zero'.
|
|
# bol_behavior is a synonym for bol_behaviour.
|
|
bol_behaviour alternating-first-char
|
|
|
|
# eol_behaviour: This specifies where the cursor should go when the
|
|
# end-of-line key (the default is the End key) is pressed.
|
|
# end: Always move to the right-most column of the line
|
|
# last-char: Always move to the right-most non-whitespace character
|
|
# alternating-end: As with 'end', unless the cursor is
|
|
# already there, in which case, as with 'last-char'.
|
|
# alternating-last-char: As with 'last-char', unless the cursor is
|
|
# already there, in which case, as with 'end'.
|
|
# eol_behavior is a synonym for eol_behaviour.
|
|
eol_behaviour alternating-end
|
|
|
|
delete_newline_on_delete_to_eol false
|
|
|
|
# Specifies whether the cursor should be at the end (false) of found text, or the
|
|
# beginning (true).
|
|
found_cursor_start false
|
|
find.return_on_abort false
|
|
find.show_context_after true
|
|
grep.context 0
|
|
|
|
max_clips 30
|
|
|
|
# If you are using KDE, you can uncomment this line to make Diakonos use KDE's
|
|
# klipper instead of its own internal clipboard. Use klipper-dcop for KDE 3,
|
|
# klipper-dbus for KDE 4.
|
|
#clipboard.external klipper-dcop
|
|
#clipboard.external klipper-dbus
|
|
|
|
# Non-KDE users can try xclip (separate, third-party software package)
|
|
# OSX users can set this to osx
|
|
#clipboard.external xclip
|
|
#clipboard.external osx
|
|
|
|
# The maximum number of undo lines held in memory per file
|
|
# Smaller files will be able to have more undo levels.
|
|
max_undo_lines 16384
|
|
|
|
convert_tabs false
|
|
strip_trailing_whitespace_on_save true
|
|
# Ensures saved files end with a newline character by adding it if necessary:
|
|
eof_newline true
|
|
save_backup_files false
|
|
|
|
diff_command diff -U 5
|
|
|
|
# Whether or not to use /usr/bin/file to determine whether files are readable
|
|
# before opening them.
|
|
use_magic_file false
|
|
|
|
fuzzy_file_find true
|
|
# fuzzy_file_find.recursive true
|
|
fuzzy_file_find.max_files 8192
|
|
# Fuzzy file finder ignores. Uses glob syntax, as per File.fnmatch
|
|
# http://www.ruby-doc.org/core/classes/File.html#M000001
|
|
# fuzzy_file_find.ignore some/relative/path/glob*
|
|
# fuzzy_file_find.ignore some/other/relative/path/glob*
|
|
|
|
fuzzy_file_find.ignore node_modules
|
|
fuzzy_file_find.ignore **/node_modules
|
|
fuzzy_file_find.ignore log
|
|
fuzzy_file_find.ignore tmp
|
|
fuzzy_file_find.ignore **/tmp
|
|
fuzzy_file_find.ignore **/dist
|
|
|
|
# By default, opened files are added to the end of the buffer list.
|
|
# i.e. with 3 buffers already open, opening a file will put it into buffer number 4
|
|
# Set open_as_first_buffer to true to put the next opened file into buffer number 1.
|
|
#open_as_first_buffer true
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Status Line
|
|
|
|
# Use "% syntax" as placeholders
|
|
# e.g. %d for decimal integers, %s for strings
|
|
status.left -- %s %s%s%s%s -- (%s) --
|
|
status.right - %s Buf %d of %d --- L%3d/%3d C%2d --
|
|
# The string to use to fill in the space between the left and right sides
|
|
# of the status line.
|
|
status.filler -
|
|
status.modified_str (modified)
|
|
status.selecting_str (selecting)
|
|
status.unnamed_str (unnamed file)
|
|
status.read_only_str (read-only)
|
|
# status.vars: any subset of:
|
|
# line row num_lines col filename modified type buffer_number num_buffers selecting selection_mode session_name read_only
|
|
status.vars filename modified read_only selecting selection_mode type session_name buffer_number num_buffers row num_lines col
|
|
status.format inverse
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Context Line
|
|
|
|
# The context line shows the wrapping context of the cursor, with respect to
|
|
# indentation. This shows the current code block(s) that the cursor is in.
|
|
|
|
context.visible false
|
|
context.combined false
|
|
context.max_levels 4
|
|
context.format inverse
|
|
context.separator |
|
|
context.separator.format red inverse
|
|
#context.max_segment_width 10
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Interaction Line
|
|
|
|
# Duration of "alert" blink (in seconds) when user has made an invalid choice
|
|
interaction.blink_duration 0.05
|
|
interaction.blink_string ***********************************************************
|
|
# Time to wait (in seconds) before accepting user keystrokes when prompting for
|
|
# a choice which has no default
|
|
interaction.choice_delay 3
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Key Configuration
|
|
#
|
|
# key <keystroke> [<keystroke>...];<function> [<arg>[,<arg>...]]
|
|
# If no function is specified, it unmaps any previous mapping.
|
|
# i.e. key <keystroke> [<keystroke>...];
|
|
# <keystroke> can be "keycode##" to specify specific keycodes.
|
|
# e.g. key keycode8;delete
|
|
# Note the lack of space after the word keycode.
|
|
|
|
# To obtain the string to use for any keychain, use the printKeychain command
|
|
# (default alt+k).
|
|
|
|
# The shell, execute and pasteShellResult commands can take variables:
|
|
|
|
# $f current buffer's filepath
|
|
# $d current buffer's directory
|
|
# $F all current buffer filepaths, space-separated
|
|
# $i get a string from user input
|
|
# $c temp file containing current clipboard text
|
|
# $s temp file containing currently selected text
|
|
|
|
key left;cursorLeft
|
|
key right;cursorRight
|
|
key up;cursorUp
|
|
key down;cursorDown
|
|
key home;cursorBOL
|
|
key esc O H;cursorBOL
|
|
key esc [ H;cursorBOL
|
|
key esc [ 1 ~ cursorBOL
|
|
key esc [ 7 ~ cursorBOL
|
|
key end;cursorEOL
|
|
key esc O F;cursorEOL
|
|
key esc [ F;cursorEOL
|
|
key esc [ 4 ~;cursorEOL
|
|
key esc [ 8 ~;cursorEOL
|
|
key pageup;pageUp
|
|
key pagedown;pageDown
|
|
#key ctrl+a;cursorBOL
|
|
key ctrl+e;cursorEOL
|
|
key alt+<;cursorBOF
|
|
key esc [ 1 ; 5 H cursor_bof
|
|
key keycode537 cursor_bof
|
|
key esc [ 1 ^ cursor_bof
|
|
key esc [ 7 ^ cursor_bof
|
|
key alt+>;cursorEOF
|
|
key esc [ 1 ; 5 F cursor_eof
|
|
key esc [ 4 ^ cursor_eof
|
|
key esc [ 8 ^ cursor_eof
|
|
key keycode532 cursor_eof
|
|
key alt+,;cursorTOV
|
|
key alt+.;cursorBOV
|
|
key ctrl+j cursor_return
|
|
key ctrl+l cursor_return :forward
|
|
key esc ` cursor_return :backward, DIFFERENT_FILE
|
|
key esc ~ cursor_return :forward, DIFFERENT_FILE
|
|
key alt+n go_to_char
|
|
key esc N go_to_char :after
|
|
key alt+p go_to_char_previous
|
|
key esc P go_to_char_previous :after
|
|
key esc up scrollUp
|
|
key esc O a scrollUp
|
|
key esc [ A scrollUp
|
|
key esc [ 1 ; 3 A scrollUp
|
|
key esc [ 1 ; 5 A scrollUp
|
|
key keycode520 scrollUp
|
|
key keycode521 scrollUp
|
|
key keycode568 scrollUp
|
|
key keycode570 scrollUp
|
|
key keycode571 scrollUp
|
|
key keycode572 scrollUp
|
|
key keycode574 scrollUp
|
|
key esc down scrollDown
|
|
key esc O b scrollDown
|
|
key esc [ B scrollDown
|
|
key esc [ 1 ; 3 B scrollDown
|
|
key esc [ 1 ; 5 B scrollDown
|
|
key keycode513 scrollDown
|
|
key keycode514 scrollDown
|
|
key keycode527 scrollDown
|
|
key keycode529 scrollDown
|
|
key keycode531 scrollDown
|
|
|
|
# Alt-right-arrow or Ctrl-right-arrow: next word
|
|
key esc right seek /(?:^|\W)(\w)/
|
|
key esc O c seek /(?:^|\W)(\w)/
|
|
key esc [ C seek /(?:^|\W)(\w)/
|
|
key esc [ 1 ; 3 C seek /(?:^|\W)(\w)/
|
|
key esc [ 1 ; 5 C seek /(?:^|\W)(\w)/
|
|
key esc [ 1 ; ; C seek /(?:^|\W)(\w)/
|
|
key keycode517 seek /(?:^|\W)(\w)/
|
|
key keycode518 seek /(?:^|\W)(\w)/
|
|
key keycode553 seek /(?:^|\W)(\w)/
|
|
key keycode555 seek /(?:^|\W)(\w)/
|
|
key keycode565 seek /(?:^|\W)(\w)/
|
|
|
|
# Alt-left-arrow or Ctrl-left-arrow: previous word
|
|
key esc left seek /\w(\W|$)/, :up
|
|
key esc O d seek /\w(\W|$)/, :up
|
|
key esc [ D seek /\w(\W|$)/, :up
|
|
key esc [ 1 ; 3 D seek /\w(\W|$)/, :up
|
|
key esc [ 1 ; 5 D seek /\w(\W|$)/, :up
|
|
key esc [ 1 ; ; D seek /\w(\W|$)/, :up
|
|
key keycode515 seek /\w(\W|$)/, :up
|
|
key keycode516 seek /\w(\W|$)/, :up
|
|
key keycode538 seek /\w(\W|$)/, :up
|
|
key keycode540 seek /\w(\W|$)/, :up
|
|
key keycode547 seek /\w(\W|$)/, :up
|
|
|
|
key esc [ 5 ; 5 ~ go_block_previous
|
|
key esc [ 6 ; 5 ~ go_block_next
|
|
key esc [ 5 ; 3 ~ go_block_outer
|
|
key esc [ 6 ; 3 ~ go_block_inner
|
|
key esc { go_to_pair_match
|
|
key esc } go_to_pair_match
|
|
|
|
key ctrl+g;goToLineAsk
|
|
key alt+b alt+b;toggleBookmark
|
|
key alt+b alt+n;goToNextBookmark
|
|
key alt+b alt+p;goToPreviousBookmark
|
|
key alt+b alt+a;addNamedBookmark
|
|
key alt+b alt+r;removeNamedBookmark
|
|
key alt+b alt+g;goToNamedBookmark
|
|
key alt+b alt+!;addNamedBookmark 1
|
|
key alt+b alt+@;addNamedBookmark 2
|
|
key alt+b alt+#;addNamedBookmark 3
|
|
key alt+b alt+$;addNamedBookmark 4
|
|
key alt+b alt+%;addNamedBookmark 5
|
|
key alt+b alt+1;goToNamedBookmark 1
|
|
key alt+b alt+2;goToNamedBookmark 2
|
|
key alt+b alt+3;goToNamedBookmark 3
|
|
key alt+b alt+4;goToNamedBookmark 4
|
|
key alt+b alt+5;goToNamedBookmark 5
|
|
key alt+t;goToTag
|
|
key alt+);goToTagUnderCursor
|
|
key alt+(;popTag
|
|
|
|
key backspace backspace
|
|
key ctrl+h backspace
|
|
key del delete
|
|
#key ctrl+k deleteLine
|
|
key ctrl+k delete_and_store_line
|
|
key ctrl+d ctrl+d delete_and_store_line
|
|
key ctrl+alt+k delete_to_eol
|
|
key ctrl+d $ delete_to_eol
|
|
key ctrl+d t delete_to
|
|
key ctrl+d ctrl+t delete_to
|
|
key ctrl+d f delete_from
|
|
key ctrl+d ctrl+f delete_from
|
|
key ctrl+d i delete_to_and_from
|
|
key ctrl+d I delete_to_and_from :inclusive
|
|
key ctrl+d ctrl+i delete_to_and_from
|
|
key esc del collapse_whitespace
|
|
key esc [ 3 ; ; ~ collapse_whitespace
|
|
key esc [ 3 ; 3 ~ collapse_whitespace
|
|
key alt+w wrap_paragraph
|
|
key alt+a columnize
|
|
key enter carriageReturn
|
|
key tab parsedIndent
|
|
#key tab indent
|
|
#key ctrl+alt+l unindent
|
|
key alt+i indent
|
|
key esc i indent
|
|
key esc I unindent
|
|
key esc [ Z unindent
|
|
key keycode353 unindent
|
|
#key tab insertSpaces 4
|
|
#key tab insertTab
|
|
key ctrl+t insertTab
|
|
key alt+j join_lines
|
|
key esc J join_lines_upward
|
|
key esc [ 1 ; 6 A move_lines direction: :up
|
|
key esc [ 1 ; 6 B move_lines direction: :down
|
|
|
|
key f1 help
|
|
key esc O P help
|
|
key esc [ 1 1 ~ help
|
|
key esc [ [ A help
|
|
key f13 help
|
|
key esc O 2 P help
|
|
key esc O 1 ; 2 P help
|
|
key f11 about
|
|
key esc [ 2 3 ~ about
|
|
key f12 openFile "~/.diakonos/diakonos.conf"
|
|
key esc [ 2 4 ~ openFile "~/.diakonos/diakonos.conf"
|
|
# Option-F12 in OSX
|
|
key f17 openFile "~/.diakonos/diakonos.conf"
|
|
|
|
key ctrl+alt+r redraw
|
|
key esc C toggleSessionSetting 'context.visible', DO_REDRAW
|
|
key ctrl+alt+d toggleSessionSetting 'display'
|
|
key esc W toggleSessionSetting 'view.wrap.visual', DO_REDRAW
|
|
key esc L toggleSessionSetting 'view.line_numbers', DO_REDRAW
|
|
|
|
key ctrl+n new_file
|
|
key ctrl+o open_file_ask
|
|
key alt+o open_matching_files
|
|
key ctrl+s save_file
|
|
key esc S save_file_as
|
|
key ctrl+w close_buffer
|
|
key ctrl+alt+o revert
|
|
key alt+! setReadOnly
|
|
key ctrl+q quit
|
|
key esc T setBufferType
|
|
key esc s esc n name_session
|
|
key esc s n name_session
|
|
key esc s esc l load_session
|
|
key esc s l load_session
|
|
key esc s esc d set_session_dir
|
|
key esc s d set_session_dir
|
|
|
|
key alt+1;switchToBufferNumber 1
|
|
key alt+2;switchToBufferNumber 2
|
|
key alt+3;switchToBufferNumber 3
|
|
key alt+4;switchToBufferNumber 4
|
|
key alt+5;switchToBufferNumber 5
|
|
key alt+6;switchToBufferNumber 6
|
|
key alt+7;switchToBufferNumber 7
|
|
key alt+8;switchToBufferNumber 8
|
|
key alt+9;switchToBufferNumber 9
|
|
# key alt+0;switchToBufferNumber 10
|
|
key alt+0 alt+0 switch_to_buffer_number 10
|
|
key alt+0 alt+1 switch_to_buffer_number 11
|
|
key alt+0 alt+2 switch_to_buffer_number 12
|
|
key alt+0 alt+3 switch_to_buffer_number 13
|
|
key alt+0 alt+4 switch_to_buffer_number 14
|
|
key alt+0 alt+5 switch_to_buffer_number 15
|
|
key alt+0 alt+6 switch_to_buffer_number 16
|
|
key alt+0 alt+7 switch_to_buffer_number 17
|
|
key alt+0 alt+8 switch_to_buffer_number 18
|
|
key alt+0 alt+9 switch_to_buffer_number 19
|
|
key alt+0 0 switch_to_buffer_number 10
|
|
key alt+0 1 switch_to_buffer_number 11
|
|
key alt+0 2 switch_to_buffer_number 12
|
|
key alt+0 3 switch_to_buffer_number 13
|
|
key alt+0 4 switch_to_buffer_number 14
|
|
key alt+0 5 switch_to_buffer_number 15
|
|
key alt+0 6 switch_to_buffer_number 16
|
|
key alt+0 7 switch_to_buffer_number 17
|
|
key alt+0 8 switch_to_buffer_number 18
|
|
key alt+0 9 switch_to_buffer_number 19
|
|
key alt+- switchToPreviousBuffer
|
|
key alt+= switchToNextBuffer
|
|
key ctrl+alt+b list_buffers
|
|
key ctrl+b 1 renumber_buffer 1
|
|
key ctrl+b 2 renumber_buffer 2
|
|
key ctrl+b 3 renumber_buffer 3
|
|
key ctrl+b 4 renumber_buffer 4
|
|
key ctrl+b 5 renumber_buffer 5
|
|
key ctrl+b 6 renumber_buffer 6
|
|
key ctrl+b 7 renumber_buffer 7
|
|
key ctrl+b 8 renumber_buffer 8
|
|
key ctrl+b 9 renumber_buffer 9
|
|
key ctrl+b 0 renumber_buffer 10
|
|
|
|
#key ctrl+space toggleSelection
|
|
key ctrl+space anchor_selection
|
|
key ctrl+c copySelection
|
|
key esc [ 2 ; 5 ~ copySelection
|
|
key ctrl+x cutSelection
|
|
key keycode383 cutSelection
|
|
key alt+u removeSelection
|
|
key ctrl+a select_all
|
|
key esc M b selection_mode_block
|
|
key esc M alt+b selection_mode_block
|
|
key esc M esc B selection_mode_block
|
|
key esc M n selection_mode_normal
|
|
key esc M alt+n selection_mode_normal
|
|
key esc M esc N selection_mode_normal
|
|
key esc ctrl+space select_line
|
|
key esc space select_wrapping_block
|
|
key.after anchor_selection ctrl+space select_word
|
|
key.after select_word ctrl+space select_word_another
|
|
key.after select_word_another ctrl+space select_word_another
|
|
key esc [ 1 ; 2 A anchor_unanchored_selection :cursor_up
|
|
key esc [ 1 ; 2 B anchor_unanchored_selection :cursor_down
|
|
key esc [ 1 ; 2 C anchor_unanchored_selection :cursor_right
|
|
key esc [ 1 ; 2 D anchor_unanchored_selection :cursor_left
|
|
key esc [ 1 ; 2 H anchor_unanchored_selection :cursor_bol
|
|
key esc [ 1 ; 2 F anchor_unanchored_selection :cursor_eol
|
|
key esc [ 1 ; 6 H anchor_unanchored_selection :cursor_bof
|
|
key esc [ 1 ; 6 F anchor_unanchored_selection :cursor_eof
|
|
key esc [ 1 ; 6 C anchor_unanchored_selection :seek, /(?:^|\W)(\w)/
|
|
key esc [ 1 ; 4 C anchor_unanchored_selection :seek, /(?:^|\W)(\w)/
|
|
key esc [ 1 ; 6 D anchor_unanchored_selection :seek, /\w(\W|$)/, :up
|
|
key esc [ 1 ; 4 D anchor_unanchored_selection :seek, /\w(\W|$)/, :up
|
|
|
|
|
|
# Select file diff in a patch
|
|
key ctrl+alt+d f select_block /^Index: /, /^(Index: |$)/, false
|
|
# Select a diff hunk in a patch
|
|
key ctrl+alt+d h select_block /^@@ /, /^(@@ |$)/, false
|
|
key esc # comment_out
|
|
key esc @ uncomment
|
|
|
|
key ctrl+alt+v;showClips
|
|
key ctrl+v;paste
|
|
key ctrl+y;unundo
|
|
key ctrl+z;undo
|
|
#key ctrl+z;suspend
|
|
key suspend;undo
|
|
#key suspend;suspend
|
|
|
|
key ctrl+f find
|
|
#key ctrl+f find case_sensitive: true
|
|
key alt+f find nil, case_sensitive: true
|
|
#key alt+f findExact
|
|
key ctrl+alt+f find nil, word_only: true
|
|
key esc F find_clip
|
|
#key ctrl+alt+f find nil, direction: :up, case_sensitive: true
|
|
key f3 find_again :down
|
|
key esc [ [ C find_again :down
|
|
key esc O R find_again :down
|
|
key esc [ 1 3 ~ find_again :down
|
|
key f15 find_again :up
|
|
key esc [ 2 8 ~ find_again :up
|
|
key esc O 2 R find_again :up
|
|
key esc [ 2 5 ~ find_again :up
|
|
key esc [ 1 ; 2 R find_again :up
|
|
key ctrl+r searchAndReplace
|
|
key alt+r searchAndReplace CASE_SENSITIVE
|
|
key ctrl+alt+u clearMatches
|
|
key esc g grep
|
|
key esc G grep_buffers
|
|
key ctrl+alt+g grep_dir
|
|
|
|
key alt+c close_code
|
|
key alt+e complete_word
|
|
key esc E complete_word :up
|
|
|
|
key f2 shell
|
|
key esc O Q shell
|
|
key esc [ 1 2 ~ shell
|
|
key esc [ [ B shell
|
|
key f8;execute
|
|
key esc d shell "diff -U 5 -w -b $c $s", "clipboard.diff"
|
|
#key esc F;shell "grep -n '$i' $F"
|
|
#key esc F;execute "grep -n '$i' $F | less"
|
|
#key esc l execute "aspell check $f"
|
|
key f14 evaluate
|
|
key esc O 2 Q evaluate
|
|
key esc [ 2 6 ~ evaluate
|
|
key esc [ 1 ; 2 Q evaluate
|
|
key ctrl+alt+c shell "ruby -c $f"
|
|
#key f10 spawn "firefox --display=:0 http://apidock.com/ruby/$i"
|
|
#key f10 spawn "DISPLAY=:0 opera --remote 'openURL(http://www.ruby-doc.org/core-1.9/classes/$i.html,new-page)' 2>&1 > /dev/null"
|
|
|
|
# To use the following:
|
|
# 1) Copy to the clipboard some Ruby code which operates on stdin text and outputs to stdout.
|
|
# 2) Select (highlight) some text to operate on.
|
|
# 3) Activate this pasteShellResult command.
|
|
# 4) The selected text should now be replaced with the script's results.
|
|
key ctrl+alt+p;pasteShellResult "cat $s | ruby $c"
|
|
#key ctrl+alt+p;pasteShellResult "cat $s | perl $c"
|
|
#key ctrl+alt+p;pasteShellResult "cat $s | python $c"
|
|
#key ctrl+alt+p;pasteShellResult "cat $s | sed -f $c"
|
|
#key ctrl+alt+p;pasteShellResult "cat $s | awk -f $c"
|
|
|
|
key alt+k printKeychain
|
|
key esc K print_mapped_function
|
|
key alt+m toggleMacroRecording
|
|
key f4 playMacro
|
|
key esc O S playMacro
|
|
key esc [ 1 4 ~ playMacro
|
|
key esc [ [ D playMacro
|
|
key f5 loadScript
|
|
key esc [ 1 5 ~ loadScript
|
|
key esc [ [ E loadScript
|
|
key f6 repeatLast
|
|
key esc [ 1 7 ~ repeatLast
|
|
key f7 operate_on_each_line
|
|
key f19 operate_on_string
|
|
key esc [ 1 8 ; 2 ~ operate_on_string
|
|
key esc f7 operate_on_lines
|
|
key esc [ 1 8 ; 3 ~ operate_on_lines
|
|
key esc [ 1 8 ; ; ~ operate_on_lines
|
|
key keycode319 operate_on_lines
|
|
|
|
# Emacs-like keychains
|
|
|
|
#key ctrl+s;find
|
|
#key ctrl+x ctrl+c;quit
|
|
#key ctrl+x ctrl+f;openFileAsk
|
|
#key ctrl+x ctrl+s;saveFile
|
|
|
|
# ------
|
|
|
|
mkey input left readline_cursor_left
|
|
mkey input esc [ D readline_cursor_left
|
|
mkey input right readline_cursor_right
|
|
mkey input esc [ C readline_cursor_right
|
|
mkey input esc esc readline_abort
|
|
mkey input ctrl+q readline_abort
|
|
mkey input ctrl+c readline_abort
|
|
mkey input enter readline_accept
|
|
mkey input backspace readline_backspace
|
|
mkey input ctrl+h readline_backspace
|
|
mkey input tab readline_complete_input
|
|
mkey input del readline_delete
|
|
mkey input ctrl+k readline_delete_line
|
|
mkey input ctrl+w readline_delete_word
|
|
|
|
mkey input up readline_cursor_up
|
|
mkey input esc [ A readline_cursor_up
|
|
mkey input down readline_cursor_down
|
|
mkey input esc [ B readline_cursor_down
|
|
mkey input home readline_cursor_bol
|
|
mkey input esc O H readline_cursor_bol
|
|
mkey input esc [ H readline_cursor_bol
|
|
mkey input esc [ 1 ~ readline_cursor_bol
|
|
mkey input esc [ 7 ~ readline_cursor_bol
|
|
mkey input ctrl+a readline_cursor_bol
|
|
mkey input end readline_cursor_eol
|
|
mkey input esc O F readline_cursor_eol
|
|
mkey input esc [ F readline_cursor_eol
|
|
mkey input esc [ 4 ~ readline_cursor_eol
|
|
mkey input esc [ 8 ~ readline_cursor_eol
|
|
mkey input ctrl+e readline_cursor_eol
|
|
mkey input pagedown readline_page_down
|
|
mkey input pageup readline_page_up
|
|
|
|
mkey input f5 readline_grep_context_decrease
|
|
mkey input esc [ 1 5 ~ readline_grep_context_decrease
|
|
mkey input esc [ [ E readline_grep_context_decrease
|
|
mkey input f6 readline_grep_context_increase
|
|
mkey input esc [ 1 7 ~ readline_grep_context_increase
|
|
|
|
mkey input f3 find_again :down
|
|
mkey input esc [ [ C find_again :down
|
|
mkey input esc O R find_again :down
|
|
mkey input esc [ 1 3 ~ find_again :down
|
|
mkey input f15 find_again :up
|
|
mkey input esc [ 2 8 ~ find_again :up
|
|
mkey input esc O 2 R find_again :up
|
|
|
|
# ---------------------------------------------------------------------
|
|
# Language Definitions
|
|
# For syntax highlighting and indentation.
|
|
|
|
# lang.<language>.tokens.<any name>[.case_insensitive] <regexp with one pair of parentheses identifying the token>
|
|
# lang.<language>.tokens.<any name>.format <format codes>
|
|
# <format codes> can be any subset of:
|
|
# normal black red green brown blue magenta cyan white standout underline inverse blink dim bold
|
|
# The numbers of colour pairs (as defined by the configuration command "colour")
|
|
# can also be used as format codes.
|
|
#
|
|
# indent.roundup: If a line's indentation is not evenly divisible by the
|
|
# indent.size, and indent.roundup is true, then the non-integer indentation
|
|
# level will be rounded up. If indent.roundup is false, then it will be
|
|
# rounded down.
|
|
# e.g. given an indent.size of 4, and a line with 6 spaces, indent.roundup
|
|
# true will make Diakonos consider the line indented 2 levels. With
|
|
# indent.roundup false, it will be considered indented 1 level.
|
|
#
|
|
# The filemask can also be used to specify specific filenames which
|
|
# don't conform to the standard extensions for a language.
|
|
|
|
# Used no matter what language
|
|
|
|
lang.all.tokens.conflict_ours ^<<<<<<<.*
|
|
lang.all.tokens.conflict_ours.format 15 bold
|
|
lang.all.tokens.conflict_theirs ^>>>>>>>.*
|
|
lang.all.tokens.conflict_theirs.format 15 bold
|
|
lang.all.tokens.conflict_separator ^=======$
|
|
lang.all.tokens.conflict_separator.format 9 bold
|
|
# lang.all.tokens.trailing_whitespace (\s+$)
|
|
# lang.all.tokens.trailing_whitespace.format 9
|
|
lang.all.surround.pair "(" "( " " )"
|
|
lang.all.surround.pair ")" "(" ")"
|
|
lang.all.surround.pair "{" "{ " " }"
|
|
lang.all.surround.pair "}" "{" "}"
|
|
lang.all.surround.pair "[" "[ " " ]"
|
|
lang.all.surround.pair "]" "[" "]"
|
|
lang.all.surround.pair "<" "< " " >"
|
|
lang.all.surround.pair ">" "<" ">"
|
|
lang.all.surround.pair "'" "'" "'"
|
|
lang.all.surround.pair "\"" "\"" "\""
|
|
lang.all.surround.pair "/*" "/*" "*/"
|
|
|
|
|
|
|
|
# Inherited by several languages
|
|
|
|
lang.shared.format.default white bold
|
|
lang.shared.format.selection inverse
|
|
lang.shared.format.found yellow inverse
|
|
lang.shared.format.pair cyan inverse
|
|
lang.shared.tokens.reserved_words.format white
|
|
lang.shared.tokens.constants.format yellow bold
|
|
lang.shared.tokens.comments.format 8 bold
|
|
lang.shared.tokens.non_alphanum.format white
|
|
lang.shared.tokens.regular_expressions.format red bold
|
|
lang.shared.tokens.singlequoted_strings.format green bold
|
|
lang.shared.tokens.doublequoted_strings.format green bold
|
|
lang.shared.tokens.backquoted_strings.format red bold
|
|
|
|
# Text (default)
|
|
|
|
lang.text.format.default white
|
|
lang.text.format.selection inverse
|
|
lang.text.format.found yellow inverse
|
|
lang.text.indent.size 2
|
|
lang.text.indent.auto true
|
|
lang.text.indent.roundup false
|
|
#lang.text.indent.using_tabs true
|
|
lang.text.tabsize 8
|
|
lang.text.wrap_margin 80
|
|
|
|
# Diakonos help files
|
|
|
|
lang.dhf.filemask \.dhf
|
|
lang.dhf.format.default white
|
|
lang.dhf.format.selection inverse
|
|
lang.dhf.format.found yellow inverse
|
|
lang.dhf.tokens.tags (^Tags: .+)
|
|
lang.dhf.tokens.tags.format blue
|
|
lang.dhf.tokens.title (^# .*)
|
|
lang.dhf.tokens.title.format 8 bold
|
|
lang.dhf.tokens.subtitle (^## .*)
|
|
lang.dhf.tokens.subtitle.format cyan bold
|
|
lang.dhf.tokens.subsubtitle (^### .*)
|
|
lang.dhf.tokens.subsubtitle.format cyan
|
|
lang.dhf.tokens.keys <(.+?)>
|
|
lang.dhf.tokens.keys.format white bold
|
|
lang.dhf.indent.size 2
|
|
lang.dhf.indent.auto true
|
|
lang.dhf.indent.roundup true
|
|
lang.dhf.wrap_margin 80
|
|
|
|
|
|
# XML
|
|
|
|
lang.xml.filemask \.(xml|xsd|xsl|rdl|aiml)$
|
|
lang.xml.format.default white
|
|
lang.xml.format.selection inverse
|
|
lang.xml.format.found yellow inverse
|
|
lang.xml.tabsize 8
|
|
lang.xml.indent.size 2
|
|
lang.xml.indent.auto true
|
|
lang.xml.indent.roundup true
|
|
#lang.xml.indent.using_tabs true
|
|
lang.xml.tokens.entities &\S+?;
|
|
lang.xml.tokens.entities.format magenta bold
|
|
lang.xml.tokens.comments.open (<!--)
|
|
lang.xml.tokens.comments.close (-->)
|
|
lang.xml.tokens.comments.format 8
|
|
lang.xml.tokens.comments.change_to xml_comment
|
|
lang.xml.comment_string "<!-- "
|
|
lang.xml.comment_close_string " -->"
|
|
lang.xml.tokens.code.open (<)(?:[^%]|$)
|
|
lang.xml.tokens.code.close (?:[^%]|^)(>)
|
|
lang.xml.tokens.code.format white bold
|
|
lang.xml.tokens.code.change_to xml_tag
|
|
lang.xml.tokens.template.open \[@--
|
|
lang.xml.tokens.template.close --@\]
|
|
lang.xml.tokens.template.format brown
|
|
lang.xml.tokens.template.change_to perl
|
|
lang.xml.closers.tag.regexp .*<([^/> ]*)(?:.+?)?>
|
|
lang.xml.closers.tag.closer </\1>
|
|
lang.xml_tag.format.default white bold
|
|
lang.xml_tag.format.selection inverse
|
|
lang.xml_tag.format.found yellow inverse
|
|
lang.xml_tag.tabsize 8
|
|
lang.xml_tag.indent.size 2
|
|
lang.xml_tag.indent.auto true
|
|
lang.xml_tag.indent.roundup true
|
|
#lang.xml_tag.indent.using_tabs true
|
|
lang.xml_tag.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.xml_tag.tokens.doublequoted_strings.format green bold
|
|
lang.xml_tag.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.xml_tag.tokens.singlequoted_strings.format green bold
|
|
lang.xml_tag.tokens.non_alphanum ([@!#$%^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.xml_tag.tokens.non_alphanum.format white
|
|
lang.xml_tag.tokens.namespaces ([a-zA-Z_-]+):
|
|
lang.xml_tag.tokens.namespaces.format yellow bold
|
|
lang.xml_comment.format.default 8
|
|
lang.xml_comment.format.selection inverse
|
|
lang.xml_comment.format.found yellow inverse
|
|
lang.xml_comment.tabsize 8
|
|
lang.xml_comment.indent.size 2
|
|
lang.xml_comment.indent.auto true
|
|
lang.xml_comment.indent.roundup true
|
|
#lang.xml_comment.indent.using_tabs true
|
|
lang.xml.surround.pair "<!--" "<!-- " " -->"
|
|
lang.xml.surround.pair "/^<(.+?)>$/" "<\1>" "</\1>"
|
|
|
|
lang.html.filemask \.([rx]?html?|php|asp|erb|handlebars|mustache)$
|
|
lang.html.format.default white
|
|
lang.html.format.selection inverse
|
|
lang.html.format.found yellow inverse
|
|
lang.html.tabsize 8
|
|
lang.html.indent.size 2
|
|
lang.html.indent.auto true
|
|
lang.html.indent.roundup true
|
|
#lang.html.indent.using_tabs true
|
|
lang.html.tokens.comments.open (<!--)
|
|
lang.html.tokens.comments.close (-->)
|
|
lang.html.tokens.comments.format 8
|
|
lang.html.tokens.comments.change_to html_comment
|
|
lang.html.comment_string "<!-- "
|
|
lang.html.comment_close_string " -->"
|
|
lang.html.tokens.entities &\S+?;
|
|
lang.html.tokens.entities.format magenta bold
|
|
lang.html.tokens.eruby.open <%
|
|
lang.html.tokens.eruby.close %>
|
|
lang.html.tokens.eruby.format 9 bold
|
|
lang.html.tokens.eruby.change_to ruby
|
|
lang.html.tokens.ezamar.open <\?r
|
|
lang.html.tokens.ezamar.close \?>
|
|
lang.html.tokens.ezamar.format 9 bold
|
|
lang.html.tokens.ezamar.change_to ruby
|
|
lang.html.tokens.ezamar-value.open \#\{
|
|
lang.html.tokens.ezamar-value.close \}
|
|
lang.html.tokens.ezamar-value.format 9 bold
|
|
lang.html.tokens.ezamar-value.change_to ruby
|
|
lang.html.tokens.php.open <\?(?:php)?
|
|
lang.html.tokens.php.close \?>
|
|
lang.html.tokens.php.format 10 bold
|
|
lang.html.tokens.php.change_to php
|
|
lang.html.tokens.code.open (<)(?:[^%]|$)
|
|
lang.html.tokens.code.close (?:[^%]|^)(>)
|
|
lang.html.tokens.code.format white bold
|
|
lang.html.tokens.code.change_to html_tag
|
|
lang.html.tokens.template-interpolation.open \{\{
|
|
lang.html.tokens.template-interpolation.close \}\}
|
|
lang.html.tokens.template-interpolation.format white bold
|
|
# lang.html.tokens.template-interpolation.change_to html_template
|
|
lang.html.closers.tag.regexp .*<([^/> ]*)(?:.+?)?>
|
|
lang.html.closers.tag.closer </\1>
|
|
lang.html_tag.format.default white bold
|
|
lang.html_tag.format.selection inverse
|
|
lang.html_tag.format.found yellow inverse
|
|
lang.html_tag.tabsize 8
|
|
lang.html_tag.indent.size 4
|
|
lang.html_tag.indent.auto true
|
|
lang.html_tag.indent.roundup true
|
|
#lang.html_tag.indent.using_tabs true
|
|
lang.html_tag.tokens.elements.case_insensitive \b(?:S(?:T(?:R(?:IKE|ONG)|YLE)|(?:CRIP|ELEC)T|U[BP]|MALL|AMP|PAN)?|T(?:[DR]|(?:AB|IT)LE|(?:FOO)?T|H(?:EAD)?|EXTAREA|BODY)|B(?:ASE(?:FONT)?|LOCKQUOTE|UTTON|ODY|DO|IG|R)?|C(?:O(?:L(?:GROUP)?|DE)|APTION|ENTER|ITE)|F(?:RAME(?:SET)?|O(?:NT|RM)|IELDSET)|A(?:CRONYM|DDRESS|PPLET|BBR|REA)?|I(?:N(?:PUT|S)|SINDEX|FRAME|MG)?|O(?:PT(?:GROUP|ION)|BJECT|L)|L(?:I(?:NK)?|EGEND|ABEL)|D(?:[DT]|I[RV]|E?L|FN)|H(?:[123456R]|EAD|TML)|NO(?:FRAMES|SCRIPT)|M(?:E(?:NU|TA)|AP)|P(?:ARAM|RE)?|KBD|UL?|EM|VA|Q)\b
|
|
lang.html_tag.tokens.elements.format cyan
|
|
lang.html_tag.tokens.attributes.case_insensitive \b(?:o(?:n(?:mouse(?:o(?:ver|ut)|down|move|up)|(?:s(?:elec|ubmi)|rese)t|key(?:press|down|up)|c(?:hange|lick)|(?:un)?load|dblclick|focus|blur)|bject)|c(?:o(?:de(?:(?:bas|typ)e)?|l(?:s(?:pan)?|or)|(?:mpac|nten)t|ords)|h(?:ar(?:off|set)?|ecked)|ell(?:padd|spac)ing|l(?:ass(?:id)?|ear)|ite)|s(?:c(?:(?:hem|op)e|rolling)|t(?:a(?:ndby|rt)|yle)|(?:hap|iz)e|elected|ummary|pan|rc)|a(?:c(?:ce(?:p(?:t-charse)?t|sskey)|tion)|l(?:i(?:gn|nk)|t)|rchive|bbr|xis)|m(?:a(?:rgin(?:height|width)|xlength)|e(?:thod|dia)|ultiple)|h(?:e(?:aders|ight)|ref(?:lang)?|ttp-equiv|space)|d(?:e(?:clare|fer)|at(?:etime|a)|i(?:sabled|r))|v(?:al(?:u(?:etyp)?e|ign)|ersion|space|link)|n(?:o(?:(?:resiz|shad)e|href|wrap)|ame)|r(?:e(?:[lv]|adonly)|ows(?:pan)?|ules)|l(?:a(?:ng(?:uage)?|bel)|ongdesc|ink)|t(?:a(?:bindex|rget)|(?:itl|yp)e|ext)|b(?:(?:gcolo|orde)r|ackground)|f(?:rame(?:border)?|ace|or)|pro(?:file|mpt)|i(?:smap|d)|enctype|usemap|width)\b
|
|
lang.html_tag.tokens.attributes.format white
|
|
lang.html_tag.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.html_tag.tokens.doublequoted_strings.format green bold
|
|
lang.html_tag.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.html_tag.tokens.singlequoted_strings.format green bold
|
|
lang.html_tag.tokens.non_alphanum ([@!#$%^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.html_tag.tokens.non_alphanum.format white
|
|
lang.html_comment.format.default 8
|
|
lang.html_comment.format.selection inverse
|
|
lang.html_comment.format.found yellow inverse
|
|
lang.html_comment.tabsize 8
|
|
lang.html_comment.indent.size 4
|
|
lang.html_comment.indent.auto true
|
|
lang.html_comment.indent.roundup true
|
|
#lang.html_comment.indent.using_tabs true
|
|
lang.html.surround.pair "<!--" "<!-- " " -->"
|
|
lang.html.surround.pair "/^<(.+?)>$/" "<\1>" "</\1>"
|
|
|
|
# CSS
|
|
|
|
lang.css.filemask \.(?:s?css|less)$
|
|
lang.css.format.default white
|
|
lang.css.format.selection inverse
|
|
lang.css.format.found yellow inverse
|
|
lang.css.tabsize 8
|
|
lang.css.indent.size 4
|
|
lang.css.indent.auto true
|
|
lang.css.indent.roundup true
|
|
#lang.css.indent.using_tabs true
|
|
lang.css.indent.indenters (\{)
|
|
lang.css.indent.unindenters (\})
|
|
lang.css.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.css.tokens.properties \b(?:b(?:o(?:rder(?:-(?:top(?:-(?:color|style|width))?|s(?:pacing|tyle)|col(?:lapse|or)|(?:righ|lef)t|bottom|width))?|ttom)|ackground(?:-(?:(?:attachmen|repea)t|position|color|image))?)|p(?:a(?:dding(?:-(?:(?:righ|lef)t|bottom|top))?|ge-break-(?:(?:befor|insid)e|after)|use(?:-(?:before|after))?)|itch(?:-range)?|lay-during|osition)|c(?:o(?:(?:unter-(?:incremen|rese)|nten)t|lor)|u(?:e(?:-(?:before|after))?|rsor)|aption-side|l(?:ear|ip))|m(?:a(?:rgin(?:-(?:(?:righ|lef)t|bottom|top))?|x-(?:height|width))|in-(?:height|width))|l(?:i(?:st-style(?:-(?:(?:imag|typ)e|position))?|ne-height)|e(?:tter-spacing|ft))|s(?:pe(?:ak(?:-(?:punctuation|numeral|header))?|ech-rate)|tress)|t(?:ext-(?:(?:decoratio|alig)n|transform|indent)|able-layout|op)|f(?:ont(?:-(?:(?:varian|weigh)t|s(?:tyl|iz)e|family))?|loat)|o(?:utline(?:-(?:color|style|width))?|verflow|rphans)|v(?:o(?:ice-family|lume)|ertical-align|isibility)|w(?:id(?:ows|th)|ord-spacing|hite-space)|e(?:mpty-cells|levation)|di(?:rection|splay)|ri(?:chness|ght)|unicode-bidi|azimuth|z-index|height|quotes)\s*:
|
|
lang.css.tokens.properties.format white bold
|
|
lang.css.tokens.colours #[A-Fa-f0-9]{6}|\b(?:aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow)\b
|
|
lang.css.tokens.colours.format yellow bold
|
|
lang.css.tokens.long_comments.open \/\*
|
|
lang.css.tokens.long_comments.close \*\/
|
|
lang.css.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.css.comment_string "/* "
|
|
lang.css.comment_close_string " */"
|
|
lang.css.tokens.numbers \b([0-9]+\.[0-9]+|[0-9]+)
|
|
lang.css.tokens.numbers.format blue bold
|
|
lang.css.tokens.units [^A-Za-z](em|pt|px)\b
|
|
lang.css.tokens.units.format cyan
|
|
lang.css.tokens.html_elements.case_insensitive \b(?:S(?:T(?:R(?:IKE|ONG)|YLE)|(?:CRIP|ELEC)T|U[BP]|MALL|AMP|PAN)?|T(?:[DR]|(?:AB|IT)LE|(?:FOO)?T|H(?:EAD)?|EXTAREA|BODY)|B(?:ASE(?:FONT)?|LOCKQUOTE|UTTON|ODY|DO|IG|R)?|C(?:O(?:L(?:GROUP)?|DE)|APTION|ENTER|ITE)|A(?:CRONYM|DDRESS|PPLET|BBR|REA)?|I(?:N(?:PUT|S)|SINDEX|FRAME|MG)?|F(?:RAME(?:SET)?|IELDSET|ORM)|O(?:PT(?:GROUP|ION)|BJECT|L)|L(?:I(?:NK)?|EGEND|ABEL)|D(?:[DT]|I[RV]|E?L|FN)|H(?:[123456R]|EAD|TML)|NO(?:FRAMES|SCRIPT)|M(?:E(?:NU|TA)|AP)|P(?:ARAM|RE)?|KBD|UL?|VA|Q)\b
|
|
lang.css.tokens.html_elements.format green
|
|
lang.css.tokens.values \b(auto|block|inherit|inline|larger|none|smaller|solid)\b
|
|
lang.css.tokens.values.format blue bold
|
|
lang.css.column_delimiters :|,
|
|
lang.css.tokens.variables @\w+
|
|
lang.css.tokens.variables.format cyan bold
|
|
|
|
# Javascript, ES6
|
|
|
|
lang.javascript.filemask \.(?:js|es6)$
|
|
lang.javascript.format.default white bold
|
|
lang.javascript.format.selection inverse
|
|
lang.javascript.format.found yellow inverse
|
|
lang.javascript.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.javascript.tokens.doublequoted_strings.format green bold
|
|
lang.javascript.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.javascript.tokens.singlequoted_strings.format green bold
|
|
# lang.javascript.tokens.backquoted_strings (`.*?[^\\]`)
|
|
# lang.javascript.tokens.backquoted_strings.format green bold
|
|
lang.javascript.tokens.interpolated_string.open (`)
|
|
lang.javascript.tokens.interpolated_string.close (`)
|
|
lang.javascript.tokens.interpolated_string.format green bold
|
|
lang.javascript.tokens.interpolated_string.change_to javascript_template_literal
|
|
lang.javascript_template_literal.format.default green bold
|
|
lang.javascript_template_literal.tokens.interpolation.open (\$\{)
|
|
lang.javascript_template_literal.tokens.interpolation.close (\})
|
|
lang.javascript_template_literal.tokens.interpolation.format 12 bold
|
|
lang.javascript_template_literal.tokens.interpolation.change_to javascript
|
|
lang.javascript.tokens.reserved_words \b(abstract|arguments|boolean|break|byte|case|catch|char|class|const|continue|debugger|default|delete|do|double|else|enum|eval|export|extends|false|final|finally|float|for|function|goto|if|implements|import|in|instanceof|int|interface|let|long|native|new|null|package|private|protected|public|return|short|static|super|switch|synchronized|this|throw|throws|transient|true|try|typeof|var|void|volatile|while|with|yield)\b
|
|
lang.javascript.tokens.reserved_words.format white
|
|
lang.javascript.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.javascript.tokens.constants.format yellow bold
|
|
lang.javascript.tokens.comments (\/\/.*)
|
|
lang.javascript.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.javascript.comment_string "/* "
|
|
lang.javascript.comment_close_string " */"
|
|
lang.javascript.tokens.long_comments.open \/\*
|
|
lang.javascript.tokens.long_comments.close \*\/
|
|
lang.javascript.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.javascript.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
lang.javascript.tokens.regular_expressions.format red bold
|
|
lang.javascript.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.javascript.tokens.non_alphanum.format white
|
|
lang.javascript.indent.size 2
|
|
lang.javascript.indent.auto true
|
|
lang.javascript.indent.roundup false
|
|
#lang.javascript.indent.using_tabs true
|
|
lang.javascript.indent.indenters ([{(])
|
|
lang.javascript.indent.unindenters ([})])
|
|
lang.javascript.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.javascript.indent.ignore ^(.+:|\s*?)$
|
|
lang.javascript.indent.closers true
|
|
lang.javascript.context.ignore ^(.+:|\s*\{?)$
|
|
lang.javascript.closers.for.regexp for$
|
|
lang.javascript.closers.for.closer { |m| "( $i = 0; $i < limit; $i++ ) {\n%_\n}" }
|
|
lang.javascript.column_delimiters =|:|,
|
|
|
|
# Ruby
|
|
|
|
lang.ruby.filemask (?:[Rr]akefile)|Gemfile|(?:\.(?:r[bu]|gem(?:spec)?|rake)$)
|
|
lang.ruby.bangmask #!.*ruby
|
|
lang.ruby.format.default = lang.shared.format.default
|
|
lang.ruby.format.selection = lang.shared.format.selection
|
|
lang.ruby.format.pair = lang.shared.format.pair
|
|
lang.ruby.format.found = lang.shared.format.found
|
|
lang.ruby.tokens.reserved_words \b(?:__FILE__|and|def|end|in|or|self|__LINE__|begin|defined\?|ensure|module|redo|super|until|BEGIN|break|do|false|next|rescue|then|when|END|case|else|for|nil|retry|true|while|alias|class|elsif|not|return|undef|yield)\b
|
|
lang.ruby.tokens.reserved_words.format = lang.shared.tokens.reserved_words.format
|
|
lang.ruby.tokens.non_modifiers ^\s*(if|unless)
|
|
lang.ruby.tokens.non_modifiers.format white
|
|
lang.ruby.tokens.modifiers \s+(if|unless)
|
|
lang.ruby.tokens.modifiers.format 9 bold
|
|
lang.ruby.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.ruby.tokens.constants.format = lang.shared.tokens.constants.format
|
|
lang.ruby.tokens.namespace ::
|
|
lang.ruby.tokens.namespace.format white
|
|
lang.ruby.tokens.symbols (:[a-zA-Z_][a-zA-Z_0-9]*)
|
|
lang.ruby.tokens.symbols.format white bold
|
|
lang.ruby.tokens.hash_keys \b(\w+):\s
|
|
lang.ruby.tokens.hash_keys.format white bold
|
|
lang.ruby.tokens.comments (#.*)
|
|
lang.ruby.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.ruby.comment_string "# "
|
|
lang.ruby.tokens.access_control ^\s*pr(?:ivate|otected)\s*$
|
|
lang.ruby.tokens.access_control.format 13 bold
|
|
lang.ruby.tokens.access_control2 (private|protected) def
|
|
lang.ruby.tokens.access_control2.format yellow
|
|
lang.ruby.tokens.long_comments.open ^=begin yellow bold
|
|
lang.ruby.tokens.long_comments.close ^=end
|
|
lang.ruby.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.ruby.tokens.instance_variables (@[A-Za-z_][A-Za-z_0-9]*)
|
|
lang.ruby.tokens.instance_variables.format white bold
|
|
lang.ruby.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
lang.ruby.tokens.regular_expressions.format red bold
|
|
lang.ruby.tokens.regular_expressions2 (%r\{.+?[^\}]\})
|
|
lang.ruby.tokens.regular_expressions2.format red bold
|
|
lang.ruby.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.ruby.tokens.doublequoted_strings.format green bold
|
|
lang.ruby.tokens.interpolated_string.open (%Q?\{)
|
|
lang.ruby.tokens.interpolated_string.close (\})
|
|
lang.ruby.tokens.interpolated_string.format red bold
|
|
lang.ruby.tokens.interpolated_string.change_to interpolated_ruby
|
|
lang.ruby.tokens.interpolated_string2.open (%Q?<)
|
|
lang.ruby.tokens.interpolated_string2.close (>)
|
|
lang.ruby.tokens.interpolated_string2.format green bold
|
|
lang.ruby.tokens.interpolated_string2.change_to interpolated_ruby
|
|
lang.ruby.tokens.interpolated_string3.open (%Q?\|)
|
|
lang.ruby.tokens.interpolated_string3.close (\|)
|
|
lang.ruby.tokens.interpolated_string3.format green bold
|
|
lang.ruby.tokens.interpolated_string3.change_to interpolated_ruby
|
|
lang.interpolated_ruby.format.default green bold
|
|
lang.interpolated_ruby.tokens.interpolation.open (#\{)
|
|
lang.interpolated_ruby.tokens.interpolation.close (\})
|
|
lang.interpolated_ruby.tokens.interpolation.format 12 bold
|
|
lang.interpolated_ruby.tokens.interpolation.change_to ruby
|
|
lang.ruby.tokens.singlequoted_strings ('.*?[^\\]'|'')
|
|
lang.ruby.tokens.singlequoted_strings.format green bold
|
|
lang.ruby.tokens.backquoted_strings (`.*?[^\\]`|``)
|
|
lang.ruby.tokens.backquoted_strings.format red bold
|
|
lang.ruby.tokens.interpolated_exec_string.open (%x\{)
|
|
lang.ruby.tokens.interpolated_exec_string.close (\})
|
|
lang.ruby.tokens.interpolated_exec_string.format red bold
|
|
lang.ruby.tokens.interpolated_exec_string.change_to interpolated_exec_ruby
|
|
lang.interpolated_exec_ruby.format.default red bold
|
|
lang.interpolated_exec_ruby.tokens.interpolation.open (#\{)
|
|
lang.interpolated_exec_ruby.tokens.interpolation.close (\})
|
|
lang.interpolated_exec_ruby.tokens.interpolation.format 9 bold
|
|
lang.interpolated_exec_ruby.tokens.interpolation.change_to ruby
|
|
lang.ruby.tokens.character_codes \W(\?\S)
|
|
lang.ruby.tokens.character_codes.format magenta bold
|
|
lang.ruby.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;~]
|
|
lang.ruby.tokens.non_alphanum.format white
|
|
lang.ruby.indent.size 2
|
|
lang.ruby.indent.auto true
|
|
lang.ruby.indent.roundup true
|
|
#lang.ruby.indent.using_tabs true
|
|
lang.ruby.tabsize 2
|
|
lang.ruby.indent.indenters ^\s*(case|(?:(?:private|protected) )?def|begin|ensure|when|else|ensure|for|while|until|elsif|if|class|module|rescue)\b|([{\[(]$|\{\s*\|[\w\s,]*\|\s*$)|\b(do)\b
|
|
lang.ruby.indent.unindenters ^\s*(end|else|elsif|ensure|when|rescue)\b|(^\s*[\]})])
|
|
lang.ruby.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(\/.+?[^\\]\/)|(^\s*#.*)|\S\s+if
|
|
lang.ruby.indent.ignore ^\s*$
|
|
lang.ruby.context.ignore ^=(begin|end)$
|
|
lang.ruby.column_delimiters =>?|:|,
|
|
|
|
# Coffeescript
|
|
|
|
lang.coffee.filemask \.coffee$
|
|
lang.coffee.format.default = lang.shared.format.default
|
|
lang.coffee.format.selection = lang.shared.format.selection
|
|
lang.coffee.format.pair = lang.shared.format.pair
|
|
lang.coffee.format.found = lang.shared.format.found
|
|
lang.coffee.tokens.reserved_words \b(?:and|catch|class|do|else|extends|false|finally|for|function|if|in|isnt|new|no|of|off|on|or|switch|then|true|try|when|while|until|yes)\b
|
|
lang.coffee.tokens.reserved_words.format = lang.shared.tokens.reserved_words.format
|
|
lang.coffee.tokens.non_modifiers ^\s*(if|unless)
|
|
lang.coffee.tokens.non_modifiers.format white
|
|
lang.coffee.tokens.modifiers \s+(if|unless)
|
|
lang.coffee.tokens.modifiers.format 9 bold
|
|
lang.coffee.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.coffee.tokens.constants.format = lang.shared.tokens.constants.format
|
|
lang.coffee.tokens.namespace ::
|
|
lang.coffee.tokens.namespace.format white
|
|
lang.coffee.tokens.symbols (:[a-zA-Z_][a-zA-Z_0-9]*)
|
|
lang.coffee.tokens.symbols.format white bold
|
|
lang.coffee.tokens.hash_keys \b(\w+):\s
|
|
lang.coffee.tokens.hash_keys.format white bold
|
|
lang.coffee.tokens.comments (#.*)
|
|
lang.coffee.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.coffee.comment_string "# "
|
|
lang.coffee.tokens.properties (@[A-Za-z_][A-Za-z_0-9]*)
|
|
lang.coffee.tokens.properties.format white bold
|
|
lang.coffee.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
lang.coffee.tokens.regular_expressions.format red bold
|
|
lang.coffee.tokens.regular_expressions2 (%r\{.+?[^\}]\})
|
|
lang.coffee.tokens.regular_expressions2.format red bold
|
|
lang.coffee.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.coffee.tokens.doublequoted_strings.format green bold
|
|
lang.coffee.tokens.singlequoted_strings ('.*?[^\\]'|'')
|
|
lang.coffee.tokens.singlequoted_strings.format green bold
|
|
lang.coffee.tokens.backquoted_strings (`.*?[^\\]`|``)
|
|
lang.coffee.tokens.backquoted_strings.format red bold
|
|
lang.coffee.tokens.interpolated_exec_string.open (%x\{)
|
|
lang.coffee.tokens.interpolated_exec_string.close (\})
|
|
lang.coffee.tokens.interpolated_exec_string.format red bold
|
|
lang.coffee.tokens.interpolated_exec_string.change_to interpolated_exec_ruby
|
|
lang.interpolated_exec_ruby.format.default red bold
|
|
lang.interpolated_exec_ruby.tokens.interpolation.open (#\{)
|
|
lang.interpolated_exec_ruby.tokens.interpolation.close (\})
|
|
lang.interpolated_exec_ruby.tokens.interpolation.format 9 bold
|
|
lang.interpolated_exec_ruby.tokens.interpolation.change_to ruby
|
|
lang.coffee.tokens.character_codes \W(\?\S)
|
|
lang.coffee.tokens.character_codes.format magenta bold
|
|
lang.coffee.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;~]
|
|
lang.coffee.tokens.non_alphanum.format white
|
|
lang.coffee.indent.size 2
|
|
lang.coffee.indent.auto true
|
|
lang.coffee.indent.roundup true
|
|
#lang.coffee.indent.using_tabs true
|
|
lang.coffee.tabsize 2
|
|
lang.coffee.indent.indenters ^\s*(when|else|try|catch|finally|for|while|until|if|class)\b|([{\[(]$|\{\s*\|[\w\s,]*\|\s*$)|\b(do)\b
|
|
lang.coffee.indent.unindenters ^\s*(end|else|when)\b|(^\s*[\]})])
|
|
lang.coffee.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(\/.+?[^\\]\/)|(^\s*#.*)|\S\s+if
|
|
lang.coffee.indent.ignore ^\s*$
|
|
lang.coffee.column_delimiters =>?|:|,
|
|
|
|
|
|
# PHP
|
|
|
|
lang.php.filemask \.php\d?$
|
|
lang.php.bangmask #!.*php|<\?php
|
|
lang.php.format.default white bold
|
|
lang.php.format.selection inverse
|
|
lang.php.format.found yellow inverse
|
|
lang.php.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.php.tokens.doublequoted_strings.format green bold
|
|
lang.php.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.php.tokens.singlequoted_strings.format green bold
|
|
lang.php.tokens.reserved_words \b(NULL|E_ALL|__wakeup|not|endwhile|__sleep|new|endswitch|__LINE__|list|endif|__FILE__|global|endforeach|while|include_once|endfor|virtual|include|enddeclare|xor|if|empty|var|elseif|TRUE|true|else|this|echo|stdClass|die|switch|do|static|default|return|function|declare|require_once|foreach|continue|require|for|class|print|FALSE|false|cfunction|PHP_VERSION|extends|case|exit|break|PHP_OS|eval|argc|parent|E_WARNING|as|or|E_ERROR|argv|old_function|E_PARSE|and)\b
|
|
lang.php.tokens.reserved_words.format white
|
|
lang.php.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.php.tokens.constants.format yellow bold
|
|
lang.php.tokens.comments (\/\/.*)
|
|
lang.php.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.php.comment_string "// "
|
|
lang.php.tokens.long_comments.open \/\*
|
|
lang.php.tokens.long_comments.close \*\/
|
|
lang.php.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.php.tokens.preprocessor (^\s*#.*)
|
|
lang.php.tokens.preprocessor.format yellow bold
|
|
lang.php.tokens.sql_string.open (<<<EOS)
|
|
lang.php.tokens.sql_string.close (EOS)
|
|
lang.php.tokens.sql_string.format 1
|
|
lang.php.tokens.sql_string.change_to sql
|
|
lang.php.tokens.js.open (<<<EOJS)
|
|
lang.php.tokens.js.close (EOJS)
|
|
lang.php.tokens.js.format 12 bold
|
|
lang.php.tokens.js.change_to java
|
|
lang.php.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.php.tokens.non_alphanum.format white
|
|
lang.php.indent.size 4
|
|
lang.php.indent.auto true
|
|
lang.php.indent.roundup false
|
|
#lang.php.indent.using_tabs true
|
|
lang.php.indent.indenters ([{\[(]$)
|
|
lang.php.indent.unindenters (^\s+[\]})])
|
|
lang.php.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.php.indent.ignore ^(.+:|\s*?)$
|
|
lang.php.context.ignore ^(.+:|\s*\{?)$
|
|
|
|
# Perl
|
|
|
|
lang.perl.filemask \.(?:pl|pm)$
|
|
lang.perl.bangmask #!.*perl
|
|
lang.perl.format.default white bold
|
|
lang.perl.format.selection inverse
|
|
lang.perl.format.found yellow inverse
|
|
lang.perl.tokens.comments (#.*)
|
|
lang.perl.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.perl.comment_string "# "
|
|
lang.perl.tokens.non_modifiers ^\s*(if|unless|until|while)
|
|
lang.perl.tokens.non_modifiers.format white
|
|
lang.perl.tokens.modifiers \s+(if|unless|until|while)
|
|
lang.perl.tokens.modifiers.format 9 bold
|
|
lang.perl.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.perl.tokens.constants.format yellow bold
|
|
lang.perl.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
lang.perl.tokens.regular_expressions.format red bold
|
|
lang.perl.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.perl.tokens.doublequoted_strings.format green bold
|
|
lang.perl.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.perl.tokens.singlequoted_strings.format green bold
|
|
lang.perl.tokens.backquoted_strings (`.*?[^\\]`)
|
|
lang.perl.tokens.backquoted_strings.format red bold
|
|
lang.perl.tokens.reserved_words \b(else|for|foreach|return|do|next|elsif|last|redo|continue|sub|goto)\b
|
|
lang.perl.tokens.reserved_words.format white
|
|
lang.perl.tokens.builtins \b(abs|accept|alarm|atan2|bind|binmode|bless|caller|chdir|chmod|chomp|chop|chown|chr|chroot|close|closedir|connect|continue|cos|crypt|dbmclose|dbmopen|defined|delete|die|do|dump|each|endgrent|endhostent|endnetent|endprotoent|endpwent|endservent|eof|eval|exec|exists|exit|exp|fcntl|fileno|flock|fork|format|formline|getc|getgrent|getgrgid|getgrnam|gethostbyaddr|gethostbyname|gethostent|getlogin|getnetbyaddr|getnetbyname|getnetent|getpeername|getpgrp|getppid|getpriority|getprotobyname|getprotobynumber|getprotoent|getpwent|getpwnam|getpwuid|getservbyname|getservbyport|getservent|getsockname|getsockopt|glob|gmtime|goto|grep|hex|import|index|int|ioctl|join|keys|kill|last|lc|lcfirst|length|link|listen|local|localtime|lock|log|lstat|m|map|mkdir|msgctl|msgget|msgrcv|msgsnd|my|next|no|oct|open|opendir|ord|our|pack|package|pipe|pop|pos|print|printf|prototype|push|q|qq|qr|quotemeta|qw|qx|rand|read|readdir|readline|readlink|readpipe|recv|redo|ref|rename|require|reset|return|reverse|rewinddir|rindex|rmdir|s|scalar|seek|seekdir|select|semctl|semget|semop|send|setgrent|sethostent|setnetent|setpgrp|setpriority|setprotoent|setpwent|setservent|setsockopt|shift|shmctl|shmget|shmread|shmwrite|shutdown|sin|sleep|socket|socketpair|sort|splice|split|sprintf|sqrt|srand|stat|study|sub|substr|symlink|syscall|sysopen|sysread|sysseek|system|syswrite|tell|telldir|tie|tied|time|times|tr|truncate|uc|ucfirst|umask|undef|unlink|unpack|unshift|untie|use|utime|values|vec|wait|waitpid|wantarray|warn|write|y)\b
|
|
lang.perl.tokens.builtins.format cyan bold
|
|
lang.perl.tokens.array_variables \s(@[A-Za-z_][A-Za-z_0-9]*)\b
|
|
lang.perl.tokens.array_variables.format red bold
|
|
lang.perl.tokens.hash_variables \s(%[A-Za-z_][A-Za-z_0-9]*)\b
|
|
lang.perl.tokens.hash_variables.format magenta bold
|
|
lang.perl.tokens.non_alphanum [!#^&*()\[\]{}/?=+\-\\|,<.>;:~]
|
|
lang.perl.tokens.non_alphanum.format white
|
|
lang.perl.indent.size 4
|
|
lang.perl.indent.auto true
|
|
lang.perl.indent.roundup true
|
|
#lang.perl.indent.using_tabs true
|
|
lang.perl.indent.indenters (case|[{\[(]$)
|
|
lang.perl.indent.unindenters (case|^\s+[\]})])
|
|
#lang.perl.indent.indenters \b(unless|else|for|while|foreach|if|do|elsif|sub)\b
|
|
#lang.perl.indent.unindenters \b(else)\b
|
|
lang.perl.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(\/.+?[^\\]\/)|(^\s*#.*)
|
|
lang.perl.indent.ignore ^\s*$
|
|
lang.perl.context.ignore ^(.+:|\s*\{?)$
|
|
lang.perl.column_delimiters =>?|:|,
|
|
|
|
|
|
# Python
|
|
|
|
lang.python.filemask \.py$
|
|
lang.python.bangmask #!.*python
|
|
lang.python.format.default white bold
|
|
lang.python.format.selection inverse
|
|
lang.python.format.found yellow inverse
|
|
lang.python.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.python.tokens.constants.format yellow bold
|
|
lang.python.tokens.comments (#.*)
|
|
lang.python.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.python.comment_string "# "
|
|
lang.python.tokens.tripledoublequoted_strings.open (""")
|
|
lang.python.tokens.tripledoublequoted_strings.close (""")
|
|
lang.python.tokens.tripledoublequoted_strings.format green bold
|
|
lang.python.tokens.tripledoublequoted_strings.change_to python_multiline_string
|
|
lang.python_multiline_string.format.default green bold
|
|
lang.python.tokens.triplesinglequoted_strings.open (''')
|
|
lang.python.tokens.triplesinglequoted_strings.close (''')
|
|
lang.python.tokens.triplesinglequoted_strings.format green bold
|
|
lang.python.tokens.triplesinglequoted_strings.change_to python_multiline_string
|
|
lang.python_multiline_string.format.default green bold
|
|
lang.python.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.python.tokens.doublequoted_strings.format green bold
|
|
lang.python.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.python.tokens.singlequoted_strings.format green bold
|
|
lang.python.tokens.backquoted_strings (`.*?[^\\]`)
|
|
lang.python.tokens.backquoted_strings.format red bold
|
|
lang.python.tokens.reserved_words \b(and|assert|break|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|not|or|pass|print|raise|return|try|while|yield)\b
|
|
lang.python.tokens.reserved_words.format white
|
|
lang.python.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;:~]
|
|
lang.python.tokens.non_alphanum.format white
|
|
lang.python.indent.size 4
|
|
lang.python.indent.auto true
|
|
lang.python.indent.roundup true
|
|
#lang.python.indent.using_tabs true
|
|
lang.python.indent.indenters \b(class|def|elif|else|except|finally|for|if|try|while)\b
|
|
#lang.python.indent.indenters :
|
|
lang.python.indent.unindenters \b(else|elif|except)\b
|
|
lang.python.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(^\s*#.*)
|
|
lang.python.indent.ignore ^\s*$
|
|
|
|
# Java
|
|
|
|
lang.java.filemask \.java$
|
|
lang.java.format.default white bold
|
|
lang.java.format.selection inverse
|
|
lang.java.format.found yellow inverse
|
|
lang.java.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.java.tokens.doublequoted_strings.format green bold
|
|
lang.java.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.java.tokens.singlequoted_strings.format green bold
|
|
lang.java.tokens.reserved_words \b(abstract|do|if|package|synchronized|boolean|double|implements|private|this|break|else|import|protected|throw|byte|extends|instanceof|public|throws|case|false|int|return|transient|catch|final|interface|short|true|char|finally|long|static|try|class|float|native|strictfp|void|const|for|new|super|volatile|continue|goto|null|switch|while|default|assert)\b
|
|
lang.java.tokens.reserved_words.format white
|
|
lang.java.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.java.tokens.constants.format yellow bold
|
|
lang.java.tokens.comments (\/\/.*)
|
|
lang.java.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.java.comment_string "/* "
|
|
lang.java.comment_close_string " */"
|
|
lang.java.tokens.long_comments.open \/\*
|
|
lang.java.tokens.long_comments.close \*\/
|
|
lang.java.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.java.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
lang.java.tokens.regular_expressions.format red bold
|
|
lang.java.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.java.tokens.non_alphanum.format white
|
|
lang.java.indent.size 4
|
|
lang.java.indent.auto true
|
|
lang.java.indent.roundup false
|
|
#lang.java.indent.using_tabs true
|
|
lang.java.indent.indenters (\{)
|
|
lang.java.indent.unindenters (\})
|
|
lang.java.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.java.indent.ignore ^(.+:|\s*?)$
|
|
lang.java.indent.closers true
|
|
lang.java.context.ignore ^(.+:|\s*\{?)$
|
|
lang.java.closers.for.regexp for$
|
|
lang.java.closers.for.closer { |m| "( $i = 0; $i < limit; $i++ ) {\n%_\n}" }
|
|
lang.java.column_delimiters =|:|,
|
|
|
|
# C
|
|
|
|
lang.c.filemask \.(c(pp|xx)?|h)$
|
|
lang.c.format.default white bold
|
|
lang.c.format.selection inverse
|
|
lang.c.format.found yellow inverse
|
|
lang.c.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.c.tokens.doublequoted_strings.format green bold
|
|
lang.c.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.c.tokens.singlequoted_strings.format green bold
|
|
lang.c.tokens.reserved_words \b(if|double|break|else|byte|case|int|return|short|char|long|static|void|for|super|continue|goto|switch|while)\b
|
|
lang.c.tokens.reserved_words.format white
|
|
lang.c.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.c.tokens.constants.format yellow bold
|
|
lang.c.tokens.comments (\/\/.*)
|
|
lang.c.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.c.comment_string "// "
|
|
lang.c.tokens.preprocessor (^\s*#.*)
|
|
lang.c.tokens.preprocessor.format yellow bold
|
|
lang.c.tokens.long_comments.open \/\*
|
|
lang.c.tokens.long_comments.close \*\/
|
|
lang.c.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
lang.c.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.c.tokens.non_alphanum.format white
|
|
lang.c.indent.size 4
|
|
lang.c.indent.auto true
|
|
lang.c.indent.roundup false
|
|
#lang.c.indent.using_tabs true
|
|
lang.c.indent.indenters_next_line (((if|for)\s*\(.+?\)\s*[^{]?|else\s*)$)
|
|
lang.c.indent.indenters (case|[{\[(]\s*$)
|
|
lang.c.indent.unindenters (case|^\s*[\]})])
|
|
lang.c.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.c.indent.ignore ^(.+:|\s*?)$
|
|
lang.c.indent.not_indented ^\s*#
|
|
lang.c.indent.triggers (\})$
|
|
lang.c.context.ignore ^(.+:|\s*\{?)$
|
|
|
|
# Configuration files
|
|
|
|
lang.conf.filemask (?:\.conf(?:ig)?|\.cfg|\.cnf|user_prefs|XF86Config)$
|
|
lang.conf.format.default white
|
|
lang.conf.format.selection inverse
|
|
lang.conf.format.found yellow inverse
|
|
lang.conf.tokens.commands ^\s*([^\s=#]+)
|
|
lang.conf.tokens.commands.format cyan bold
|
|
lang.conf.tokens.comments (^\s*#.*)
|
|
lang.conf.tokens.comments.format yellow bold
|
|
lang.conf.comment_string "# "
|
|
lang.conf.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.conf.tokens.doublequoted_strings.format green bold
|
|
lang.conf.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.conf.tokens.singlequoted_strings.format green bold
|
|
lang.conf.indent.size 4
|
|
lang.conf.indent.auto true
|
|
lang.conf.indent.roundup true
|
|
#lang.conf.indent.using_tabs true
|
|
|
|
# crontab
|
|
|
|
lang.crontab.filemask (?:^|\/)crontab$
|
|
lang.crontab.format.default white
|
|
lang.crontab.format.selection inverse
|
|
lang.crontab.format.found yellow inverse
|
|
lang.crontab.tokens.comments (^\s*#.*)
|
|
lang.crontab.tokens.comments.format yellow bold
|
|
lang.crontab.comment_string "# "
|
|
lang.crontab.tokens.schedule ^((?:[0-9\/*,-]+\s+){5})
|
|
lang.crontab.tokens.schedule.format cyan bold
|
|
lang.crontab.tokens.commands ^(\S+=.+)
|
|
lang.crontab.tokens.commands.format cyan
|
|
lang.crontab.indent.size 4
|
|
lang.crontab.indent.auto true
|
|
lang.crontab.indent.roundup true
|
|
#lang.crontab.indent.using_tabs true
|
|
|
|
lang.fstab.filemask ^fstab$
|
|
lang.fstab.format.default white
|
|
lang.fstab.format.selection inverse
|
|
lang.fstab.format.found yellow inverse
|
|
lang.fstab.tokens.comments (^\s*#.*)
|
|
lang.fstab.tokens.comments.format yellow bold
|
|
lang.fstab.comment_string "# "
|
|
lang.fstab.indent.size 4
|
|
lang.fstab.indent.auto true
|
|
lang.fstab.indent.roundup true
|
|
#lang.fstab.indent.using_tabs true
|
|
|
|
# SQL
|
|
|
|
lang.sql.filemask \.sql$
|
|
lang.sql.format.default white bold
|
|
lang.sql.format.selection inverse
|
|
lang.sql.format.found yellow inverse
|
|
lang.sql.indent.size 4
|
|
lang.sql.indent.auto true
|
|
lang.sql.indent.roundup false
|
|
#lang.sql.indent.using_tabs true
|
|
#lang.sql.tokens.reserved_words.case_insensitive \b(ABSOLUTE|ACCESS|ACTION|ADD|ADMIN|AFTER|ALIAS|ALL|ALLOCATE|AND|ANY|ARE|AS|ASC|ASSERTION|AT|AUDIT|AUTHORIZATION|AVG|BEFORE|BEGIN|BETWEEN|BIT_LENGTH|BOTH|BREADTH|BY|CASCADE|CASCADED|CASE|CAST|CATALOG|CHAR_LENGTH|CHARACTER_LENGTH|CHECK|CLASS|CLOSE|CLUSTER|COALESCE|COBOL|COLLATE|COLLATION|COLUMN|COMPLETION|COMPRESS|COMPUTED|CONCAT|CONNECT|CONNECTION|CONSTRAINT|CONSTRAINTS|CONSTRUCTOR|CONTINUE|CONVERT|CORRESPONDING|COUNT|CROSS|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|CURRENT_USER|CURRENT|CURSOR|CYCLE|DATA|DAY|DBHIGH|DBKEY|DBLOW|DBMAC|DEALLOCATE|DECLARE|DECODE|DEFAULT|DEFERRABLE|DEFERRED|DEPTH|DEREF|DESC|DESCRIBE|DESCRIPTOR|DESTROY|DESTRUCTOR|DIAGNOSTICS|DICTIONARY|DISCONNECT|DISTINCT|DO|DOMAIN|EACH|ELEMENT|ELSE|ELSEIF|END-EXEC|END|EQUALS|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXISTS|EXTERNAL|EXTERNALLY|EXTRACT|FALSE|FILE|FIRST|FOR|FOREIGN|FORTRAN|FOUND|FROM|FULL|FUNCTION|GENERAL|GET|GLOBAL|GO|GOTO|GROUP|HAVING|HOUR|IDENTIFIED|IDENTITY|IF|IGNORE|IMMEDIATE|IN|INCREMENT|INDEX|INDICATOR|INITIAL|INITIALLY|INNER|INOUT|INPUT|INSENSITIVE|INSTEAD|INTERSECT|INTERVAL|INTO|IS|ISOLATION|JOIN|KEY|LABEL|LANGUAGE|LAST|LEADING|LEAVE|LEFT|LESS|LEVEL|LIKE|LIMIT|LOCAL|LOCK|LOOP|LOWER|MATCH|MAX|MAXEXTENTS|MIN|MINUS|MINUTE|MLSLABEL|MLS_LABEL_FORMAT|MODE|MODIFY|MODULE|MONTH|MOVE|MULTISET|NAMES|NATIONAL|NATURAL|NEW_TABLE|NEXT|NO|NOAUDIT|NOCOMPRESS|NONE|NOT|NOWAIT|NULL|NULLIF|NUMBER|NVL|OCTET_LENGTH|OF|OFF|OFFLINE|OID|OLD|OLD_TABLE|ON|ONLINE|ONLY|OPEN|OPERATION|OPERATORS|OPTION|OR|ORDER|OTHERS|OUT|OUTER|OUTPUT|OVERLAPS|PAD|PARAMETER|PARTIAL|PASCAL|PCTFREE|PENDANT|PLI|POSITION|PRECISION|PREORDER|PRESERVE|PRIMARY|PRIOR|PRIVATE|PRIVILEGES|PROCEDURE|PROTECTED|PUBLIC|RAW|READ|READUP|REAL|RECORD|RECURSIVE|REF|REFERENCES|REFERENCING|RELATIVE|RENAME|REPLACE|REPRESENTATION|RESIGNAL|RESOURCE|RESTRICT|RETURN|RETURNS|RIGHT|ROLE|ROUTINE|ROW|ROWID|ROWNUM|ROWS|SAVEPOINT|SCHEMA|SCROLL|SEARCH|SECOND|SECTION|SENSITIVE|SEQUENCE|SESSION|SESSION_USER|SET|SHARE|SIGNAL|SIMILAR|SIZE|SOME|SPACE|SPECIFIC|SQL|SQLCODE|SQLERROR|SQLEXCEPTION|SQLSTATE|SQLWARNING|START|STRUCTURE|SUBSTRING|SUCCESSFUL|SUM|SYNONYM|SYSDATE|SYSTEM_USER|TABLE|TEMPLATE|TEMPORARY|TEST|THAN|THEN|THERE|SQ92|TIMEZONE_HOUR|TIMEZONE_MINUTE|TO|TRAILING|TRANSACTION|TRANSLATE|TRANSLATION|TRIGGER|TRIM|TRUE|TUPLE|TYPE|UID|UNDER|UNION|UNIQUE|UNKNOWN|UPPER|USAGE|USER|USING|VALIDATE|VALUE|VALUES|VARIABLE|VARIANT|VIRTUAL|VARYING|VIEW|VISIBLE|VOID|WAIT|WHEN|WHENEVER|WHERE|WHILE|WITH|WITHOUT|WORK|WRITE|WRITEDOWN|WRITEUP|YEAR|ZONE)\b
|
|
lang.sql.tokens.reserved_words.case_insensitive \b(ALL|AND|ANY|AS|ASC|BEGIN|BY|CASCADE|CASE|CAST|CHECK|COALESCE|COLUMN|CONSTRAINT|COUNT|CURRENT_DATE|CURRENT_TIME|CURRENT_TIMESTAMP|CURSOR|DECLARE|DEFAULT|DESC|DISTINCT|DO|ELSE|ELSEIF|END|EXCEPT|EXISTS|FALSE|FIRST|FOR|FOREIGN|FOUND|FROM|FULL|FUNCTION|GROUP|HAVING|HOUR|IF|IN|INCREMENT|INDEX|INNER|INPUT|INSTEAD|INTERSECT|INTERVAL|INTO|IS|JOIN|KEY|LANGUAGE|LAST|LEFT|LIKE|LIMIT|LOOP|MAX|MIN|NATURAL|NEXT|NO|NONE|NOT|NULL|NUMBER|OF|OFF|OLD|ON|ONLY|OR|ORDER|OUT|OUTER|PARTIAL|PRECISION|PRIMARY|REAL|RECORD|REF|REFERENCES|REPLACE|RESTRICT|RETURN|RETURNS|RIGHT|SCHEMA|SEQUENCE|SET|SUM|TABLE|TEMPORARY|THAN|THEN|TO|TRANSACTION|TRIGGER|TRUE|TYPE|UNION|UNIQUE|UPPER|USING|VALUE|VALUES|VARYING|VIEW|WHEN|WHERE|WHILE|WITH|WITHOUT|WORK)\b
|
|
lang.sql.tokens.reserved_words.format white
|
|
lang.sql.tokens.commands.case_insensitive \b(ALTER|COMMENT|COMMIT|CREATE|DELETE|DROP|EXEC|EXECUTE|FETCH|GRANT|INSERT|PERFORM|PREPARE|REVOKE|ROLLBACK|SELECT|UPDATE)\b
|
|
lang.sql.tokens.commands.format cyan
|
|
lang.sql.tokens.data_types.case_insensitive \b(BIT|BOOLEAN|CHAR|CHARACTER|DATE|DEC|DECIMAL|DOUBLE|FLOAT|INT|INTEGER|INTERVAL|LONG|NCHAR|NUMBER|NUMERIC|REAL|RECORD|ROW|SMALLINT|STRUCTURE|TIME|TIMESTAMP|TUPLE|VARCHAR|VARCHAR2)\b
|
|
lang.sql.tokens.data_types.format brown
|
|
lang.sql.tokens.comments (--.*)
|
|
lang.sql.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.sql.comment_string "-- "
|
|
lang.sql.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.sql.tokens.singlequoted_strings.format green bold
|
|
lang.sql.tokens.typos (==)
|
|
lang.sql.tokens.typos.format 15 bold
|
|
lang.sql.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.sql.tokens.non_alphanum.format white
|
|
lang.sql.indent.indenters ((?:\(|BEGIN|DECLARE|FROM|LOOP|ORDER BY|SELECT|SET|WHERE)$)
|
|
lang.sql.indent.unindenters (^\s+(?:\)|;|BEGIN|DECLARE|END))
|
|
lang.sql.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')
|
|
lang.sql.context.ignore ^(\W+)$
|
|
|
|
# Bash
|
|
|
|
lang.bash.filemask (?:\.(?:ebuild|bash_profile|bashrc)|PKGBUILD)$
|
|
lang.bash.bangmask #!.*(?:ba)?sh\b
|
|
lang.bash.format.default white bold
|
|
lang.bash.format.selection inverse
|
|
lang.bash.format.found yellow inverse
|
|
lang.bash.indent.size 2
|
|
lang.bash.indent.auto true
|
|
lang.bash.indent.roundup true
|
|
#lang.bash.indent.using_tabs true
|
|
lang.bash.tabsize 2
|
|
lang.bash.tokens.comments (^\s*#.*)
|
|
lang.bash.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.bash.comment_string "# "
|
|
lang.bash.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.bash.tokens.singlequoted_strings.format green bold
|
|
lang.bash.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.bash.tokens.doublequoted_strings.format green bold
|
|
lang.bash.tokens.backquoted_strings (`.*?[^\\]`)
|
|
lang.bash.tokens.backquoted_strings.format red bold
|
|
lang.bash.indent.indenters (\{)
|
|
lang.bash.indent.unindenters (\})
|
|
lang.bash.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.bash.indent.ignore ^(.+:|\s*?)$
|
|
|
|
# Tcl
|
|
|
|
lang.tcl.filemask \.tcl$
|
|
lang.tcl.bangmask #!.*tcl
|
|
lang.tcl.format.default white bold
|
|
lang.tcl.format.selection inverse
|
|
lang.tcl.format.found yellow inverse
|
|
lang.tcl.indent.size 4
|
|
lang.tcl.indent.auto true
|
|
lang.tcl.indent.roundup true
|
|
#lang.tcl.indent.using_tabs true
|
|
lang.tcl.tabsize 4
|
|
lang.tcl.tokens.comments (^\s*#.*)
|
|
lang.tcl.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.tcl.comment_string "# "
|
|
lang.tcl.tokens.reserved_words \b(encoding|incr|pid|tcl_endOfWord|Tcl|eof|info|tcl_findLibrary|after|error|interp|pkg_mkIndex|tcl_startOfNextWord|append|eval|join|proc|tcl_startOfPreviousWord|array|exec|lappend|puts|tcl_wordBreakAfter|auto_execok|exit|lassign|pwd|tcl_wordBreakBefore|auto_import|expr|lindex|re_syntax|tcltest|auto_load|fblocked|linsert|read|tclvars|auto_mkindex|fconfigure|list|regexp|tell|auto_mkindex_old|fcopy|llength|registry|time|auto_qualify|file|load|regsub|trace|auto_reset|fileevent|lrange|rename|unknown|bgerror|filename|lrepeat|resource|unload|binary|flush|lreplace|return|unset|break|for|lsearch|scan|update|catch|foreach|lset|seek|uplevel|cd|format|lsort|set|upvar|clock|gets|memory|socket|variable|close|glob|msgcat|source|vwait|concat|global|namespace|split|while|continue|history|open|string|dde|http|package|subst|dict|if|parray|switch)\b
|
|
lang.tcl.tokens.reserved_words.format white
|
|
lang.tcl.tokens.variables (\$[A-Za-z_][A-Za-z_0-9]*)\b
|
|
lang.tcl.tokens.variables.format yellow bold
|
|
lang.tcl.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.tcl.tokens.doublequoted_strings.format green bold
|
|
lang.tcl.tokens.non_alphanum ([!@#$%\^&*()\[\]{}/?=+\-\\|,<.>;:])
|
|
lang.tcl.tokens.non_alphanum.format white
|
|
lang.tcl.indent.indenters (\{)
|
|
lang.tcl.indent.unindenters (\})
|
|
lang.tcl.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
|
|
lang.diff.filemask (?:\.(?:diff|patch|rej)|COMMIT_EDITMSG)$
|
|
lang.diff.format.default white
|
|
lang.diff.format.selection inverse
|
|
lang.diff.format.found yellow inverse
|
|
lang.diff.indent.size 4
|
|
lang.diff.indent.auto false
|
|
#lang.diff.indent.using_tabs true
|
|
lang.diff.tabsize 4
|
|
lang.diff.tokens.oldfile (^--- .+$)
|
|
lang.diff.tokens.oldfile.format red bold
|
|
lang.diff.tokens.newfile (^\+\+\+ .+$)
|
|
lang.diff.tokens.newfile.format green bold
|
|
lang.diff.tokens.oldline (^-.+$)
|
|
lang.diff.tokens.oldline.format red bold
|
|
lang.diff.tokens.newline (^\+.+$)
|
|
lang.diff.tokens.newline.format green bold
|
|
lang.diff.tokens.location (^@@.+$)
|
|
lang.diff.tokens.location.format green
|
|
lang.diff.tokens.filediff (^Only in .+$)
|
|
lang.diff.tokens.filediff.format magenta bold
|
|
lang.diff.tokens.diff_command (^diff .+$)
|
|
lang.diff.tokens.diff_command.format 13 bold
|
|
|
|
lang.yaml.filemask (?:\.ya?ml)$
|
|
lang.yaml.format.default white bold
|
|
lang.yaml.format.selection inverse
|
|
lang.yaml.format.found yellow inverse
|
|
lang.yaml.tokens.value_indicator (:)(?: |$)
|
|
lang.yaml.tokens.value_indicator.format white
|
|
lang.yaml.tokens.key_indicator (\? )
|
|
lang.yaml.tokens.key_indicator.format white
|
|
lang.yaml.tokens.nested_series (?:^|[^-])(- )
|
|
lang.yaml.tokens.nested_series.format magenta bold
|
|
lang.yaml.tokens.series_separator (,)
|
|
lang.yaml.tokens.series_separator.format white
|
|
lang.yaml.tokens.inline_series ([\[\]])
|
|
lang.yaml.tokens.inline_series.format white
|
|
lang.yaml.tokens.inline_keyed ([{}])
|
|
lang.yaml.tokens.inline_keyed.format white
|
|
lang.yaml.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.yaml.tokens.doublequoted_strings.format green bold
|
|
lang.yaml.tokens.singlequoted_strings ('.*?[^\\]'|'')
|
|
lang.yaml.tokens.singlequoted_strings.format green bold
|
|
lang.yaml.tokens.block_scalar (\|[0-9+-]*)$
|
|
lang.yaml.tokens.block_scalar.format blue bold
|
|
lang.yaml.tokens.folded_scalar (>[0-9+-]*)$
|
|
lang.yaml.tokens.folded_scalar.format blue bold
|
|
lang.yaml.tokens.document_header ^(---.*)$
|
|
lang.yaml.tokens.document_header.format 10 bold
|
|
lang.yaml.tokens.document_terminator ^(\.\.\.)
|
|
lang.yaml.tokens.document_terminator.format 10
|
|
lang.yaml.tokens.directive_indicator ^(%.*)
|
|
lang.yaml.tokens.directive_indicator.format 10
|
|
lang.yaml.tokens.comment_indicator (#.+)
|
|
lang.yaml.tokens.comment_indicator.format = lang.shared.tokens.comments.format
|
|
lang.yaml.comment_string "# "
|
|
lang.yaml.tokens.anchor_indicator (&\w+)
|
|
lang.yaml.tokens.anchor_indicator.format red bold
|
|
lang.yaml.tokens.alias_indicator (\*\w+)
|
|
lang.yaml.tokens.alias_indicator.format yellow
|
|
lang.yaml.tokens.tag (!\w*)
|
|
lang.yaml.tokens.tag.format yellow bold
|
|
lang.yaml.tokens.null (~|null)
|
|
lang.yaml.tokens.null.format red
|
|
lang.yaml.tabsize 8
|
|
lang.yaml.indent.size 2
|
|
lang.yaml.indent.auto true
|
|
lang.yaml.indent.roundup true
|
|
lang.yaml.indent.indenters :$
|
|
lang.yaml.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(^\s*#.*)
|
|
lang.yaml.indent.ignore ^\s*$
|
|
|
|
lang.haml.filemask \.haml$
|
|
lang.haml.format.default white bold
|
|
lang.haml.format.selection inverse
|
|
lang.haml.format.found yellow inverse
|
|
lang.haml.tabsize 8
|
|
lang.haml.indent.size 2
|
|
lang.haml.indent.auto true
|
|
lang.haml.indent.roundup true
|
|
lang.haml.indent.using_tabs false
|
|
lang.haml.tokens.code.open [=~-]
|
|
lang.haml.tokens.code.close $
|
|
lang.haml.tokens.code.format 9 bold
|
|
lang.haml.tokens.code.change_to ruby
|
|
lang.haml.tokens.tags (%\w+\b)
|
|
lang.haml.tokens.tags.format white
|
|
lang.haml.tokens.hash.open [{\[]
|
|
lang.haml.tokens.hash.close [}\]]
|
|
lang.haml.tokens.hash.format blue bold
|
|
lang.haml.tokens.hash.change_to ruby
|
|
lang.haml.tokens.class \.[a-zA-Z0-9_-]+
|
|
lang.haml.tokens.class.format cyan bold
|
|
lang.haml.tokens.id ^\s*#[a-zA-Z0-9_-]+
|
|
lang.haml.tokens.id.format cyan
|
|
lang.haml.tokens.xml !!!
|
|
lang.haml.tokens.xml.format magenta bold
|
|
lang.haml.tokens.comments (^\s*-#.*)
|
|
lang.haml.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.haml.comment_string "-# "
|
|
lang.haml.tokens.html_comment ^ *(\/.*)
|
|
lang.haml.tokens.html_comment.format = lang.shared.tokens.comments.format
|
|
lang.haml.tokens.line_joiner \|$
|
|
lang.haml.tokens.line_joiner.format 12 bold
|
|
|
|
lang.sass.filemask \.sass$
|
|
lang.sass.format.default white
|
|
lang.sass.format.selection inverse
|
|
lang.sass.format.found yellow inverse
|
|
lang.sass.tabsize 2
|
|
lang.sass.indent.size 2
|
|
lang.sass.indent.auto true
|
|
lang.sass.indent.roundup true
|
|
lang.sass.indent.using_tabs false
|
|
lang.sass.tokens.rules ^[A-Za-z0-9,.#\s_-]+$
|
|
lang.sass.tokens.rules.format cyan bold
|
|
lang.sass.tokens.attributes ^ *(?::\S+|[A-Za-z0-9_-]+: )
|
|
lang.sass.tokens.attributes.format white bold
|
|
lang.sass.tokens.colour #(?:[A-Fa-f0-9]{3}){1,2}\b
|
|
lang.sass.tokens.colour.format yellow bold
|
|
lang.sass.tokens.units \d+ *(px|em|pt)\b
|
|
lang.sass.tokens.units.format brown
|
|
lang.sass.tokens.silent_comments (\/\/.*)
|
|
lang.sass.tokens.silent_comments.format = lang.shared.tokens.comments.format
|
|
lang.sass.tokens.loud_comments (\/\*.*)
|
|
lang.sass.tokens.loud_comments.format = lang.shared.tokens.comments.format
|
|
lang.sass.tokens.line_joiner \|$
|
|
lang.sass.tokens.line_joiner.format 12 bold
|
|
lang.sass.tokens.parent (&):
|
|
lang.sass.tokens.parent.format red bold
|
|
|
|
lang.makefile.filemask Makefile$
|
|
lang.makefile.format.default white
|
|
lang.makefile.format.selection inverse
|
|
lang.makefile.format.found yellow inverse
|
|
lang.makefile.tokens.assignment_lhs ^\s*([^\s=]+)\s*[+?]?=
|
|
lang.makefile.tokens.assignment_lhs.format white bold
|
|
lang.makefile.tokens.comments (^\s*#.*)
|
|
lang.makefile.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.makefile.comment_string "# "
|
|
lang.makefile.tokens.targets (^\S+):
|
|
lang.makefile.tokens.targets.format yellow bold
|
|
lang.makefile.tokens.references @?\$(?:\(.+?\)|\w+)
|
|
lang.makefile.tokens.references.format green bold
|
|
lang.makefile.tokens.keywords ^\s*(else|endif|export|ifdef|ifeq|ifndef|ifneq)
|
|
lang.makefile.tokens.keywords.format cyan bold
|
|
lang.makefile.indent.size 8
|
|
lang.makefile.indent.auto true
|
|
lang.makefile.indent.roundup true
|
|
lang.makefile.indent.using_tabs true
|
|
lang.makefile.indent.indenters ^(\S+:|ifdef|ifeq|ifndef|ifneq|else)
|
|
lang.makefile.indent.unindenters ^(\S+:|endif)
|
|
lang.makefile.indent.preventers (^\s*#.*)
|
|
lang.makefile.indent.ignore ^\s*$
|
|
|
|
lang.bind.bangmask ^(@\s|\$TTL|;.*(?:bind|BIND|Bind))
|
|
lang.bind.format.default white bold
|
|
lang.bind.format.selection inverse
|
|
lang.bind.format.found yellow inverse
|
|
lang.bind.tokens.comments (;.*)
|
|
lang.bind.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.bind.comment_string "; "
|
|
lang.bind.tokens.ttl \$TTL
|
|
lang.bind.tokens.ttl.format yellow bold
|
|
lang.bind.tokens.number \s(\d+)(?:[^0-9.mhdw]|$)
|
|
lang.bind.tokens.number.format blue bold
|
|
lang.bind.tokens.time \b(\d+)[mhdw]
|
|
lang.bind.tokens.time.format red bold
|
|
lang.bind.tokens.domain (?:[a-z][\w-]+\.)+[a-z][\w-]+\.?
|
|
lang.bind.tokens.domain.format cyan bold
|
|
lang.bind.tokens.ip4address \b\d+\.\d+\.\d+\.\d+\b
|
|
lang.bind.tokens.ip4address.format cyan
|
|
lang.bind.tokens.keywords1 \b(IN)\b
|
|
lang.bind.tokens.keywords1.format white
|
|
lang.bind.tokens.keywords2 \b(A|CNAME|MX|NS|SOA|TXT)\b
|
|
lang.bind.tokens.keywords2.format yellow bold
|
|
lang.bind.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.bind.tokens.doublequoted_strings.format green bold
|
|
lang.bind.indent.size 8
|
|
lang.bind.indent.auto true
|
|
lang.bind.indent.roundup true
|
|
lang.bind.indent.using_tabs false
|
|
|
|
lang.markdown.filemask \.(?:md|markdown)
|
|
lang.markdown.format.default white
|
|
lang.markdown.format.selection inverse
|
|
lang.markdown.format.found yellow inverse
|
|
lang.markdown.tokens.title (^# .*)
|
|
lang.markdown.tokens.title.format 8 bold
|
|
lang.markdown.tokens.subtitle (^## .*)
|
|
lang.markdown.tokens.subtitle.format cyan bold
|
|
lang.markdown.tokens.subsubtitle (^###+ .*)
|
|
lang.markdown.tokens.subsubtitle.format cyan
|
|
lang.markdown.tokens.list_item ^\s*\*
|
|
lang.markdown.tokens.list_item.format white bold
|
|
lang.markdown.tokens.code ^(?: {4,}|\t)\s*.+
|
|
lang.markdown.tokens.code.format yellow bold
|
|
lang.markdown.indent.size 2
|
|
lang.markdown.indent.auto true
|
|
lang.markdown.indent.roundup true
|
|
lang.markdown.wrap_margin 80
|
|
|
|
lang.gherkin.filemask \.feature
|
|
lang.gherkin.format.default white
|
|
lang.gherkin.format.selection inverse
|
|
lang.gherkin.format.found yellow inverse
|
|
lang.gherkin.tokens.keyword ^\s*(And|As a|Background|But|Examples|Scenarios|Given|GivenScenario|I want|In order to|Scenario Outline|Then|When)
|
|
lang.gherkin.tokens.keyword.format white bold
|
|
lang.gherkin.tokens.feature_header ^\s*(Feature:.+)
|
|
lang.gherkin.tokens.feature_header.format 8 bold
|
|
lang.gherkin.tokens.scenario_header ^\s*(Scenario:.+)
|
|
lang.gherkin.tokens.scenario_header.format 8
|
|
lang.gherkin.indent.size 2
|
|
lang.gherkin.indent.auto true
|
|
lang.gherkin.indent.roundup true
|
|
lang.gherkin.indent.indenters ^\s*(?:Feature|Scenario):
|
|
lang.gherkin.wrap_margin 80
|
|
|
|
lang.haskell.filemask \.hs$
|
|
# lang.haskell.bangmask #!.*ruby
|
|
lang.haskell.format.default = lang.shared.format.default
|
|
lang.haskell.format.selection = lang.shared.format.selection
|
|
lang.haskell.format.found = lang.shared.format.found
|
|
lang.haskell.tokens.reserved_words \b(case|class|data|deriving|do|else|if|import|in|infix|infixl|infixr|instance|let|of|module|newtype|then|type|where)\b
|
|
lang.haskell.tokens.reserved_words.format = lang.shared.tokens.reserved_words.format
|
|
# lang.haskell.tokens.non_modifiers ^\s*(if|unless)
|
|
# lang.haskell.tokens.non_modifiers.format white
|
|
# lang.haskell.tokens.modifiers \s+(if|unless)
|
|
# lang.haskell.tokens.modifiers.format 44
|
|
# lang.haskell.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
# lang.haskell.tokens.constants.format = lang.shared.tokens.constants.format
|
|
# lang.haskell.tokens.symbols [^:](:[a-zA-Z_][a-zA-Z_0-9]*)
|
|
# lang.haskell.tokens.symbols.format white bold
|
|
lang.haskell.tokens.comments (--.*)
|
|
lang.haskell.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.haskell.comment_string "-- "
|
|
lang.haskell.tokens.long_comments.open \{-
|
|
lang.haskell.tokens.long_comments.close -\}
|
|
lang.haskell.tokens.long_comments.format = lang.shared.tokens.comments.format
|
|
# lang.haskell.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
# lang.haskell.tokens.regular_expressions (\/.+?[^\\]\/)
|
|
# lang.haskell.tokens.regular_expressions.format red bold
|
|
# lang.haskell.tokens.regular_expressions2 (%r\{.+?[^\}]\})
|
|
# lang.haskell.tokens.regular_expressions2.format red bold
|
|
lang.haskell.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.haskell.tokens.doublequoted_strings.format green bold
|
|
lang.haskell.tokens.singlequoted_strings ('.*?[^\\]'|'')
|
|
lang.haskell.tokens.singlequoted_strings.format green bold
|
|
# lang.haskell.tokens.backquoted_strings (`.*?[^\\]`|``)
|
|
# lang.haskell.tokens.backquoted_strings.format red bold
|
|
lang.haskell.tokens.numbers \b([0-9]+[.e][0-9]+|[0-9]+)
|
|
lang.haskell.tokens.numbers.format blue bold
|
|
lang.haskell.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;~]
|
|
lang.haskell.tokens.non_alphanum.format white
|
|
lang.haskell.indent.size 4
|
|
lang.haskell.indent.auto true
|
|
lang.haskell.indent.roundup true
|
|
lang.haskell.tabsize 4
|
|
lang.haskell.indent.indenters ^\s*(else|if|where)\b|([{\[(=]$|(?:do|let|of|where)$|\{\s*\|[\w\s,]*\|\s*$)
|
|
# lang.haskell.indent.unindenters ^\s*(end|else|elsif|ensure|when|rescue)\b|(^\s*[\]})])
|
|
lang.haskell.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(\/.+?[^\\]\/)|(^\s*--.*)
|
|
lang.haskell.indent.ignore ^\s*$
|
|
# lang.haskell.context.ignore ^=(begin|end)$
|
|
lang.haskell.column_delimiters =>?|:|,
|
|
|
|
# Lua
|
|
|
|
lang.lua.filemask (?:\.lua)$
|
|
lang.lua.bangmask #!.*lua\b
|
|
lang.lua.format.default white bold
|
|
lang.lua.format.selection inverse
|
|
lang.lua.format.found yellow inverse
|
|
lang.lua.indent.size 4
|
|
lang.lua.indent.auto true
|
|
lang.lua.indent.roundup true
|
|
#lang.lua.indent.using_tabs true
|
|
lang.lua.tabsize 4
|
|
lang.lua.tokens.reserved_words \b(and|break|do|else|elseif|end|for|function|if|local|nil|not|or|repeat|return|then|until|while)\b
|
|
lang.lua.tokens.reserved_words.format = lang.shared.tokens.reserved_words.format
|
|
lang.lua.tokens.comments (--.*)
|
|
lang.lua.tokens.comments.format = lang.shared.tokens.comments.format
|
|
lang.lua.comment_string "-- "
|
|
lang.lua.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.lua.tokens.singlequoted_strings.format green bold
|
|
lang.lua.tokens.doublequoted_strings (\".*?[^\\]?\")
|
|
lang.lua.tokens.doublequoted_strings.format green bold
|
|
lang.lua.tokens.numbers \b([0-9]+[.e][0-9]+|[0-9]+)
|
|
lang.lua.tokens.numbers.format blue bold
|
|
lang.lua.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;~]
|
|
lang.lua.tokens.non_alphanum.format = lang.shared.tokens.non_alphanum.format
|
|
lang.lua.indent.indenters ([{\[(])
|
|
lang.lua.indent.unindenters ([}\])])
|
|
lang.lua.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(\/\/.*)
|
|
lang.lua.indent.ignore ^(.+:|\s*?)$
|
|
|
|
# Octave
|
|
|
|
lang.octave.filemask \.m$
|
|
lang.octave.bangmask #!.*octave
|
|
lang.octave.format.default white
|
|
lang.octave.format.selection inverse
|
|
lang.octave.format.found yellow inverse
|
|
lang.octave.tokens.constants \b([A-Z_]+|[A-Z_][A-Z0-9_]+)\b
|
|
lang.octave.tokens.constants.format yellow bold
|
|
lang.octave.tokens.comments (#.*)
|
|
lang.octave.tokens.comments.format cyan
|
|
lang.octave.comment_string "# "
|
|
lang.octave.tokens.doublequoted_strings (\".*?[^\\]\")
|
|
lang.octave.tokens.doublequoted_strings.format green bold
|
|
lang.octave.tokens.singlequoted_strings ('.*?[^\\]')
|
|
lang.octave.tokens.singlequoted_strings.format green bold
|
|
lang.octave.tokens.backquoted_strings (`.*?[^\\]`)
|
|
lang.octave.tokens.backquoted_strings.format red bold
|
|
lang.octave.tokens.reserved_words \b(break|case|catch|continue|else|elseif|end|endif|endfor|endfunction|endwhile|false|for|function|global|if|otherwise|persistent|return|setenv|switch|true|try|while)\b
|
|
lang.octave.tokens.reserved_words.format magenta bold
|
|
lang.octave.tokens.non_alphanum [@!#$%^&*()\[\]{}/?=+\-\\|,<.>;:~]
|
|
lang.octave.tokens.non_alphanum.format white
|
|
lang.octave.tokens.numbers \b(([+-])?\d+(\.\d+)?(e\w+)?)\b
|
|
lang.octave.tokens.numbers.format yellow bold
|
|
lang.octave.indent.size 4
|
|
lang.octave.indent.auto true
|
|
lang.octave.indent.roundup true
|
|
#lang.octave.indent.using_tabs true
|
|
lang.octave.indent.indenters \b(case|catch|else|elseif|end|endif|endfor|endfunction|for|function|if|otherwise|switch|try|while)\b
|
|
lang.octave.indent.unindenters \b(else|elseif|end|endif|endfor|endfunction|endwhile)\b
|
|
lang.octave.indent.preventers (\".+?[^\\]\")|('.+?[^\\]')|(`.+?[^\\]`)|(^\s*#.*)
|
|
lang.octave.indent.ignore ^\s*$
|
|
|
|
# Vue.js Webpack
|
|
|
|
lang.vue.filemask \.vue$
|
|
lang.vue.format.default white
|
|
lang.vue.format.selection inverse
|
|
lang.vue.format.found yellow inverse
|
|
lang.vue.tabsize 8
|
|
lang.vue.indent.size 2
|
|
lang.vue.indent.auto true
|
|
lang.vue.indent.roundup true
|
|
lang.vue.tokens.comments.open (<!--)
|
|
lang.vue.tokens.comments.close (-->)
|
|
lang.vue.tokens.comments.format 8
|
|
lang.vue.tokens.comments.change_to html_comment
|
|
lang.vue.comment_string "<!-- "
|
|
lang.vue.comment_close_string " -->"
|
|
lang.vue.tokens.entities &\S+?;
|
|
lang.vue.tokens.entities.format magenta bold
|
|
lang.vue.tokens.html_template.open <template.*?>
|
|
lang.vue.tokens.html_template.close </template>
|
|
lang.vue.tokens.html_template.format 47
|
|
lang.vue.tokens.html_template.change_to html
|
|
lang.vue.tokens.script.open <script.*?>
|
|
lang.vue.tokens.script.close </script>
|
|
lang.vue.tokens.script.format 47
|
|
lang.vue.tokens.script.change_to javascript
|
|
lang.vue.tokens.css.open <style.*?>
|
|
lang.vue.tokens.css.close </style>
|
|
lang.vue.tokens.css.format 47
|
|
lang.vue.tokens.css.change_to css
|
|
lang.vue.tokens.code.open (<)(?:[^%]|$)
|
|
lang.vue.tokens.code.close (?:[^%]|^)(>)
|
|
lang.vue.tokens.code.format white bold
|
|
lang.vue.tokens.code.change_to html_tag
|
|
lang.vue.tokens.template-interpolation.open \{\{
|
|
lang.vue.tokens.template-interpolation.close \}\}
|
|
lang.vue.tokens.template-interpolation.format white bold
|
|
lang.vue.closers.tag.regexp .*<([^/> ]*)(?:.+?)?>
|
|
lang.vue.closers.tag.closer </\1>
|
|
lang.vue.surround.pair "<!--" "<!-- " " -->"
|
|
lang.vue.surround.pair "/^<(.+?)>$/" "<\1>" "</\1>"
|
|
|
|
|
|
# Other configuration files can be included.
|
|
# If a setting is specified again, it overrides the previous setting given
|
|
# higher up in the configuration file(s).
|
|
|
|
#include ~/.diakonos/custom.conf
|
|
|
|
# Uncomment this line if your terminal supports 256 colours.
|
|
#include ~/.diakonos/diakonos-256-colour.conf
|
|
|
|
# Load extensions like this, specifying the extension directory (relative to ~/.diakonos/extensions)
|
|
#load_extension dk-git
|