1
0
mirror of https://github.com/cmur2/joe-syntax.git synced 2024-11-14 06:56:17 +01:00

Remove stuff irrelevant for upstream

This commit is contained in:
cn 2015-02-18 14:53:43 +01:00
parent 1bdac950b3
commit 7476e509bd
4 changed files with 0 additions and 332 deletions

View File

@ -1,208 +0,0 @@
How JOE syntax highlighting works
=================================
*from [c.jsf](http://joe-editor.hg.sourceforge.net/hgweb/joe-editor/joe-editor/file/tip/syntax/c.jsf.in),
slightly modified*
A (deterministic) state machine which performs lexical analysis of C.
(This is the "assembly language" of syntax highlighting. A separate
program could be used to convert a regular expression NFA syntax into this
format).
Each state begins with:
:<name> <color-name>
\<name\> is the state's name.
\<color-name\> is the color used for characters eaten by the state
(really a symbol for a user definable color).
The first state defined is the initial state.
Within a state, define transitions (jumps) to other states. Each
jump has the form:
<character-list> <target-state-name> [<option>s]
There are three ways to specify \<character-list\>s, either * for any
character not otherwise specified, & to match the character in the
delimiter match buffer or a literal list of characters within quotes
(ranges and escape sequences allowed). When the next character matches
any in the list, a jump to the target-state is taken and the character is
eaten (we advance to the next character of the file to be colored).
The * transition should be the first transition specified in the state.
There are several options:
* __noeat__ - Do not eat the character, instead feed it to the next state
(this tends to make the states smaller, but be careful: you
can make infinite loops). 'noeat' implies 'recolor=-1'.
* __recolor=-N__ - Recolor the past N characters with the color of the
target-state. For example once /* is recognized as the
start of C comment, you want to color the /* with the C
comment color with recolor=-2.
* __mark__ - Mark beginning of a region with current position.
* __markend__ - Mark end of region.
* __recolormark__ - Recolor all of the characters in the marked region with
the color of the target-state. If markend is not given,
all of the characters up to the current position are recolored.
Note that the marked region can not cross line boundaries and
must be on the same line as recolormark.
* __buffer__ - Start copying characters to a string buffer, beginning with this
one (it's ok to not terminate buffering with a matching
'strings' option- the buffer is limited to leading 23
characters).
* __save_c__ - Save character in delimiter match buffer.
* __save_s__ - Copy string buffer to delimiter match buffer.
* __strings__ - A list of strings follows. If the buffer matches any of the
given strings, a jump to the target-state in the string list
is taken instead of the normal jump.
* __istrings__ - Same as strings, but case is ignored.
Note: strings and istrings should be the last option on the
line. They cause any options which follow them to be ignored.
* __hold__ - Stop buffering string- a future 'strings' or 'istrings' will
look at contents of buffer at this point. Useful for distinguishing
commands and function calls in some languages 'write 7' is a command
'write (' is a function call- hold lets us stop at the space and delay
the string lookup until the ( or 7.
The format of the string list is:
"string" <target-state> [<options>s]
"string" <target-state> [<options>s]
"&" <target-state> [<options>s] # matches contents of delimiter match buffer
done
(all of the options above are allowed except "strings", "istrings" and "noeat". noeat is
always implied after a matched string).
Weirdness: only states have colors, not transitions. This means that you
sometimes have to make dummy states with
* <next-state> noeat
just to get a color specification.
Delimiter match buffer is for perl and shell: a regex in perl can be s<..>(...)
and in shell you can say: <<EOS ....... EOS
New feature: subroutines
------------------------
Highlighter state machines can now make subroutine calls. This works by
template instantiation: the called state machine is included in your
current state machine, but is modified so that the return address points
to the called. There is still no run-time stack (the state is represented
as a single integer plus the saved delimiter string).
Recursion is allowed, but is self limited to 5 levels.
To call a subroutine, use the 'call' option:
"\"" fred call=string(dquote)
The subroutine called 'string' is called and the jump to 'fred' is
ignored. The 'dquote' option is passed to the subroutine.
The subroutine itself returns to the caller like this:
"\"" whatever return
If we're in a subroutine, the return is made. Otherwise the jump
to 'whatever' is made.
There are several ways of delimiting subroutines which show up in how it
is called. Here are the options:
* __call=string()__ - A file called string.jsf is the subroutine.
The entire file is the subroutine. The starting
point is the first state in the file.
* __call=library.string()__ - A file called library.jsf has the subroutine.
The subroutine within the file is called string.
* __call=.string()__ - There is a subroutine called string in the current file.
When a subroutine is within a file, but is not the whole file, it is delimited
as follows:
.subr string
. . . states for string subroutine . . .
.end
Option flags can be passed to subroutines which control preprocessor-like
directives. For example:
.ifdef dquote
"\"" idle return
.endif
.ifdef squote
"'" idle return
.endif
.else if also available. .ifdefs can be nested.
Obsolete feature: sync lines
----------------------------
the sync lines specification no longer matter. We now always parse
from the beginning of the file. Here is the old description:
Define no. sync lines
You can say:
* '-200' means 200 lines
* '-' means always start parsing from beginning of file when we lose sync
if nothing is specified, the default is -50
Colors and attributes
---------------------
Define colors and attributes. Give a list of attributes, one
background color and one foreground color (default is used if
color is left out).
Attributes:
bold inverse blink dim underline
Standard colors:
Foreground:
white cyan magenta blue yellow green red black
Background:
bg_white bg_cyan bg_magenta bg_blue bg_yellow bg_green bg_red bg_black
For 16 color and 256 color xterms: "export TERM=xterm-16color", these
brighter than normal colors are available:
> Note that you need an xterm which was compiled to support 16 or 256 colors
> and a matching termcap/terminfo entry for it.
Foreground:
WHITE CYAN MAGENTA BLUE YELLOW GREEN RED BLACK
Background:
bg_WHITE bg_CYAN bg_MAGENTA bg_BLUE bg_YELLOW bg_GREEN bg_RED bg_BLACK
For 256 color xterm: "export TERM=xterm-256color", these become available:
> Note that you need an xterm which was compiled to support 256 colors and a
> matching termcap/terminfo entry for it.
fg_RGB and bg_RGB, where R, G, and B range from 0 - 5. So: fg_500 is bright red.
fg_NN and bg_NN give shades of grey, where the intensity, NN, ranges from 0 - 23.

View File

@ -1,66 +0,0 @@
# JOE Syntax Highlighting
This directory mainly contains *improved and completely new* JOE syntax files
fixing bugs in the original files and adding support for new languages.
## Using
### *.jsf
To enable the .jsf files in this repository they need to appear in JOEs
*syntax* directory. This is likely to be */usr/share/joe/syntax* when using
Debian and APT or */usr/local/Cellar/joe/3.7/share/joe/syntax* when using brew
on Mac OS X. You may download the
[latest jsf-bundle](https://github.com/downloads/cmur2/joe-syntax/jsf-bundle_2.tar)
and place it's contents into the *syntax* directory (Note: this bundle might
be outdated compared to the repository's state).
A maybe better way to achieve this is to clone this repository somewhere
onto your hard disk and establish symlinks to all jsf files in the *syntax*
directory.
### ftyperc (only needed to enable new languages)
To enable the enhanced *ftyperc* from this repository to gain syntax
highlighting support for new languages without overwriting
*/etc/joe/ftyperc*, you may place the modified one in *~/.joe/* as
*~/.joe/ftyperc*.
## How JOE syntax highlighting works
See [HowItWorks.md](https://github.com/cmur2/joe-syntax/blob/master/HowItWorks.md)
which is a reworked version of the header of
[c.jsf](http://joe-editor.hg.sourceforge.net/hgweb/joe-editor/joe-editor/file/tip/syntax/c.jsf.in).
Another good resource might be
[jsf.jsf](http://joe-editor.hg.sourceforge.net/hgweb/joe-editor/joe-editor/file/tip/syntax/jsf.jsf.in).
## Other Syntax Files
* [d.jsf](https://gist.github.com/1032393)
## Licensing
Every .jsf file from the original repository is under GPL2 as [JOE](http://sourceforge.net/projects/joe-editor/).
Every .jsf file created and modified exclusively by [me](https://github.com/cmur2) is under GPL2 as [JOE](http://sourceforge.net/projects/joe-editor/).
Files with unknown license info:
* [elixir.jsf](https://github.com/cmur2/joe-syntax/blob/master/elixir.jsf) which is created by [Andrew Lisin](https://github.com/avli) under GPL v2 ([comment](https://github.com/cmur2/joe-syntax/pull/18#issuecomment-69193456))
* [erlang.jsf](https://github.com/cmur2/joe-syntax/blob/master/go.jsf) which is created by [Christian Nicolai](https://github.com/cmur2) and then modified by Jonas Rosling and enhanced with a small tweak from [raev](https://github.com/raev)
* [go.jsf](https://github.com/cmur2/joe-syntax/blob/master/go.jsf) which is entirely contributed by [Daniel Vargas](https://github.com/danielvargas)
* [js.jsf](https://github.com/cmur2/joe-syntax/blob/master/js.jsf) which is created by [Christian Nicolai](https://github.com/cmur2) and then modified by [Rebecca Turner](https://github.com/iarna)
* [json.jsf](https://github.com/cmur2/joe-syntax/blob/master/json.jsf) which is entirely contributed by [Rebecca Turner](https://github.com/iarna)
* [lsl.jsf](https://github.com/cmur2/joe-syntax/blob/master/lsl.jsf) which is from [Zai Lynch](https://wiki.secondlife.com/wiki/User:Zai_Lynch) under GPL v1 (delivered by [Rebecca Turner](https://github.com/iarna))
* [md.jsf](https://github.com/cmur2/joe-syntax/blob/master/md.jsf) which is created by [Christian Nicolai](https://github.com/cmur2) and then modified by Jonas Rosling
* [powershell.jsf](https://github.com/cmur2/joe-syntax/blob/master/powershell.jsf) which is entirely contributed by [Oskar Liljeblad](https://github.com/osklil)
* [puppet.jsf](https://github.com/cmur2/joe-syntax/blob/master/puppet.jsf) which is created by [Christian Nicolai](https://github.com/cmur2) and then modified by [Eric Eisenhart](https://github.com/eeisenhart)
* [sql.jsf](https://github.com/cmur2/joe-syntax/blob/master/sql.jsf) which is from an "unknown source" (delivered by [Rebecca Turner](https://github.com/iarna))
## Links
For JOE see [here](http://joe-editor.sourceforge.net/).
For JOE project see [here](http://sourceforge.net/projects/joe-editor/).
For original JOE syntax files see [here](http://joe-editor.hg.sourceforge.net/hgweb/joe-editor/joe-editor/file/tip/syntax).
*You can find this repository [here](https://github.com/cmur2/joe-syntax).*

View File

@ -1,12 +0,0 @@
#!/bin/bash
PREFIX="jsf-bundle"
if [[ $1 == "" ]]; then
echo "Number missing!"
exit 1
else
num=$1
fi
tar cvf "${PREFIX}_$num.tar" --exclude="*.part.jsf" ./*.jsf

View File

@ -1,46 +0,0 @@
#!/bin/bash
SRC=`pwd`
DST="/usr/share/joe/syntax"
#DST="/tmp/js"
if [ "$UID" -ne 0 ]; then
echo "You should run this as root. Else you may not have suitable rights to modify $DST."
echo "If this is incorrect plz modify this script. Exit."
exit 1
fi
if [ ! -e $DST ]; then
echo "The destination directory for JOEs syntax files does not exist: $DST"
echo "Note that the default location is correct on Debian systems so plz modify this script for your system."
exit 1
fi
echo "This script will replace all *.jsf files from $DST (the 'originals')"
echo "which exist in $SRC (the 'improved') too after backing them up"
echo "with symlinks pointing to $SRC/<file> if not already done so."
echo
read -p "Do you want to continue? (y/n): " answer
if [ "$answer" != "y" ]; then
echo "You did not answer exactly with 'y', abort."
exit 2
fi
find $SRC -name "*.jsf" | while read file_src; do
name=`basename $file_src`
file_dst="$DST/$name"
echo -n "$name: "
if [ -h $file_dst ]; then
echo "is already a symlink, skip."
continue
fi
if [ -e $file_dst ]; then
echo -n "backup to $file_dst.orig, "
mv $file_dst "$file_dst.orig"
fi
echo "create symlink."
ln -s $file_src $file_dst
done