Menu
▾
▴
[ jEdit-commits ] SF.net SVN: jedit:[21733] plugins/Console/trunk
|
From: <ez...@us...> - 2012-05-28 15:48:18
|
Revision: 21733
http://jedit.svn.sourceforge.net/jedit/?rev=21733&view=rev
Author: ezust
Date: 2012-05-28 15:48:05 +0000 (Mon, 28 May 2012)
Log Message:
-----------
Got rid of jcfunc.jar in favor of building sources into Console.jar
Modified Paths:
--------------
plugins/Console/trunk/Console.props
plugins/Console/trunk/build.xml
Added Paths:
-----------
plugins/Console/trunk/jcfunc/
plugins/Console/trunk/jcfunc/CF.java
plugins/Console/trunk/jcfunc/Description.java
plugins/Console/trunk/jcfunc/Sequences.java
plugins/Console/trunk/jcfunc/escMatcher.java
plugins/Console/trunk/jcfunc/parameters/
plugins/Console/trunk/jcfunc/parameters/paramSGR.java
Removed Paths:
-------------
plugins/Console/trunk/lib/
Modified: plugins/Console/trunk/Console.props
===================================================================
--- plugins/Console/trunk/Console.props 2012-05-28 14:53:06 UTC (rev 21732)
+++ plugins/Console/trunk/Console.props 2012-05-28 15:48:05 UTC (rev 21733)
@@ -16,9 +16,6 @@
plugin.console.ConsolePlugin.depend.2=plugin errorlist.ErrorListPlugin 1.9
plugin.console.ConsolePlugin.depend.3=optional plugin projectviewer.ProjectPlugin 3.4.2
-# Library for parsing ansi vt100 color codes.
-plugin.console.ConsolePlugin.jars=jcfunc.jar
-
# Menu
plugin.console.ConsolePlugin.menu=console run-last-console-command - \
commando - commando-compile commando-run console-clear - \
Modified: plugins/Console/trunk/build.xml
===================================================================
--- plugins/Console/trunk/build.xml 2012-05-28 14:53:06 UTC (rev 21732)
+++ plugins/Console/trunk/build.xml 2012-05-28 15:48:05 UTC (rev 21733)
@@ -10,7 +10,7 @@
<property file="build.properties" />
<property file="../build.properties" />
- <property name="javadoc.packagenames" value="console.*" />
+ <property name="javadoc.packagenames" value="console.*,jcfunc.*" />
<property name="plugin.dependencies" value="ErrorList,InfoViewer,ProjectViewer" />
<property name="docs-proc.target" value="xsltproc" />
<property name="dist.target" value="dist.complete" />
@@ -18,14 +18,8 @@
<import file="${build.support}/plugin-build.xml" />
-
- <!-- Prepare for build - ensure extra jar is in the right place -->
- <target name="build.prepare">
- <copy todir="${install.dir}">
- <fileset dir="lib" includes="jcfunc.jar" />
- </copy>
- </target>
+
<!-- Extra files that get put into the jar file, above and beyond
the default set (which always includes actions,dockables,services.xml,
@@ -48,7 +42,6 @@
<pathelement location="${jedit.plugins.dir}/ProjectViewer.jar"/>
<pathelement location="${jedit.plugins.dir}/ErrorList.jar" />
<pathelement location="${jedit.plugins.dir}/InfoViewer.jar" />
- <pathelement location="${jedit.plugins.dir}/jcfunc.jar" />
</path>
</project>
Added: plugins/Console/trunk/jcfunc/CF.java
===================================================================
--- plugins/Console/trunk/jcfunc/CF.java (rev 0)
+++ plugins/Console/trunk/jcfunc/CF.java 2012-05-28 15:48:05 UTC (rev 21733)
@@ -0,0 +1,520 @@
+/*
+ * CF.java - definitions of all control functions
+ * :tabSize=8:indentSize=8:noTabs=false:
+ * :folding=explicit:collapseFolds=1:
+ *
+ * Copyright (C) 2012, Artem Bryantsev
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+package jcfunc;
+
+//{{{ CF enum
+/**
+ Definitions (acronyms) of all control functions.
+
+ see <a href="http://www.ecma-international.org/publications/standards/Ecma-048.htm">
+ "Standart ECMA-48 Control functions for coded characters sets"</a>
+ */
+public enum CF {
+ /** Acknowledge */
+ ACK,
+
+ /** Application program command */
+ APC,
+
+ /** Bell */
+ BEL,
+
+ /** Break permitted here */
+ BPH,
+
+ /** Backspace */
+ BS,
+
+ /** Cansel */
+ CAN,
+
+ /** Cursor backward tabulation */
+ CBT,
+
+ /** Cancel character */
+ CCH,
+
+ /** Cursor character absolute */
+ CHA,
+
+ /** Cursor forward tabulation */
+ CHT,
+
+ /** Coding method delimiter */
+ CMD,
+
+ /** Cursor next line */
+ CNL,
+
+ /** Cursor preceding line */
+ CPL,
+
+ /** Active position report */
+ CPR,
+
+ /** Carriage return */
+ CR,
+
+ /** Control sequence introducer */
+ CSI,
+
+ /** Cursor tabulation control */
+ CTC,
+
+ /** Cursor left */
+ CUB,
+
+ /** Cursor down */
+ CUD,
+
+ /** Cursor right */
+ CUF,
+
+ /** Cursor position */
+ CUP,
+
+ /** Cursor up */
+ CUU,
+
+ /** Cursor line tabulation */
+ CVT,
+
+ /** Device attributes */
+ DA ,
+
+ /** Define area qualification */
+ DAQ,
+
+ /** Delete character */
+ DCH,
+
+ /** Device control string */
+ DCS,
+
+ /** Device control one */
+ DC1,
+
+ /** Device control two */
+ DC2,
+
+ /** Device control three */
+ DC3,
+
+ /** Device control four */
+ DC4,
+
+ /** Delete line */
+ DL ,
+
+ /** Data link escape */
+ DLE,
+
+ /** Disable manual input */
+ DMI,
+
+ /** Device status report */
+ DSR,
+
+ /** Dimension text area */
+ DTA,
+
+ /** Erase in area */
+ EA ,
+
+ /** Erase character */
+ ECH,
+
+ /** Erase in page */
+ ED ,
+
+ /** Erase in field */
+ EF ,
+
+ /** Erase in line */
+ EL ,
+
+ /** End of medium */
+ EM ,
+
+ /** Enable manual input */
+ EMI,
+
+ /** Enquiry */
+ ENQ,
+
+ /** End of transmission */
+ EOT,
+
+ /** End of guarded area */
+ EPA,
+
+ /** End of selected area */
+ ESA,
+
+ /** Escape */
+ ESC,
+
+ /** End of transmission block */
+ ETB,
+
+ /** End of text */
+ ETX,
+
+ /** Form feed */
+ FF ,
+
+ /** Function key */
+ FNK,
+
+ /** Font selection */
+ FNT,
+
+ /** Graphic character combination */
+ GCC,
+
+ /** Graphic size modification */
+ GSM,
+
+ /** Graphic size selection */
+ GSS,
+
+ /** Character position absolute */
+ HPA,
+
+ /** Character position backward */
+ HPB,
+
+ /** Character position forward */
+ HPR,
+
+ /** Character tabulation */
+ HT ,
+
+ /** Character tabulation with justification */
+ HTJ,
+
+ /** Character tabulation set */
+ HTS,
+
+ /** Character and line position */
+ HVP,
+
+ /** Insert character */
+ ICH,
+
+ /** Identify device control string */
+ IDCS,
+
+ /** Identify graphic subrepertoire */
+ IGS,
+
+ /** Insert line */
+ IL ,
+
+ /** Interrupt */
+ INT,
+
+ /** Information separator one (us - unit separator) */
+ IS1,
+
+ /** Information separator two (rs - record separator) */
+ IS2,
+
+ /** Information separator three (gs - group separator) */
+ IS3,
+
+ /** Information separator four (fs - file separator) */
+ IS4,
+
+ /** Justify */
+ JFY,
+
+ /** Line feed */
+ LF ,
+
+ /** Locking-shift zero */
+ LS0,
+
+ /** Locking-shift one */
+ LS1,
+
+ /** Locking-shift one right */
+ LS1R,
+
+ /** Locking-shift two */
+ LS2,
+
+ /** Locking-shift two right */
+ LS2R,
+
+ /** Locking-shift three */
+ LS3,
+
+ /** Locking-shift three right */
+ LS3R,
+
+ /** Media copy */
+ MC ,
+
+ /** Message waiting */
+ MW ,
+
+ /** Negative acknowledge */
+ NAK,
+
+ /** No break here */
+ NBH,
+
+ /** Next line */
+ NEL,
+
+ /** Next page */
+ NP ,
+
+ /** Null */
+ NUL,
+
+ /** Operating system command */
+ OSC,
+
+ /** Presentation expand or contract */
+ PEC,
+
+ /** Page format selection */
+ PFS,
+
+ /** Partial line forward */
+ PLD,
+
+ /** Partial line backward */
+ PLU,
+
+ /** Privacy message */
+ PM ,
+
+ /** Preceding page */
+ PP ,
+
+ /** Page position absolute */
+ PPA,
+
+ /** Page position backward */
+ PPB,
+
+ /** Page position forward */
+ PPR,
+
+ /** Parallel texts */
+ PTX,
+
+ /** Private use one */
+ PU1,
+
+ /** Private use two */
+ PU2,
+
+ /** Quad */
+ QUAD,
+
+ /** Repeat */
+ REP,
+
+ /** Reverse line feed */
+ RI ,
+
+ /** Reset to initial state */
+ RIS,
+
+ /** Reset mode */
+ RM ,
+
+ /** Set additional character separation */
+ SACS,
+
+ /** Select alternative presentation variants */
+ SAPV,
+
+ /** Single character introducer */
+ SCI,
+
+ /** Select character orientation */
+ SCO,
+
+ /** Select character path */
+ SCP,
+
+ /** Set character spacing */
+ SCS,
+
+ /** Scroll down */
+ SD ,
+
+ /** Start directed string */
+ SDS,
+
+ /** Select editing extent */
+ SEE,
+
+ /** Sheet eject and feed */
+ SEF,
+
+ /** Select graphic rendition */
+ SGR,
+
+ /** Select character spacing */
+ SHS,
+
+ /** Shift-in */
+ SI ,
+
+ /** Select implicit movement direction */
+ SIMD,
+
+ /** Scroll left */
+ SL ,
+
+ /** Set line home */
+ SLH,
+
+ /** Set line limit */
+ SLL,
+
+ /** Set line spacing */
+ SLS,
+
+ /** Set mode */
+ SM ,
+
+ /** Shift-out */
+ SO ,
+
+ /** Start of heading */
+ SOH,
+
+ /** Start of string */
+ SOS,
+
+ /** Start of guarded area */
+ SPA,
+
+ /** Select presentation directions */
+ SPD,
+
+ /** Set page home */
+ SPH,
+
+ /** Spacing increment */
+ SPI,
+
+ /** Set page limit */
+ SPL,
+
+ /** Select print quality and rapidity */
+ SPQR,
+
+ /** Scroll right */
+ SR ,
+
+ /** Set reduced character separation */
+ SRCS,
+
+ /** Start reversed string */
+ SRS,
+
+ /** Start of selected area */
+ SSA,
+
+ /** Select size unit */
+ SSU,
+
+ /** Set space width */
+ SSW,
+
+ /** Single-shift two */
+ SS2,
+
+ /** Single-shift three */
+ SS3,
+
+ /** String terminator */
+ ST ,
+
+ /** Selective tabulation */
+ STAB,
+
+ /** Set transmit state */
+ STS,
+
+ /** Start of text */
+ STX,
+
+ /** Scroll up */
+ SU ,
+
+ /** Substitute */
+ SUB,
+
+ /** Select line spacing */
+ SVS,
+
+ /** Synchronous idle */
+ SYN,
+
+ /** Tabulation aligned centred */
+ TAC,
+
+ /** Tabulation aligned leading edge */
+ TALE,
+
+ /** Tabulation aligned trailing edge */
+ TATE,
+
+ /** Tabulation clear */
+ TBC,
+
+ /** Tabulation centred on character */
+ TCC,
+
+ /** Tabulation stop remove */
+ TSR,
+
+ /** Thin space specification */
+ TSS,
+
+ /** Line position absolute */
+ VPA,
+
+ /** Line position backward */
+ VPB,
+
+ /** Line position forward */
+ VPR,
+
+ /** Line tabulation */
+ VT ,
+
+ /** Line tabulation set */
+ VTS
+}
+//}}}
+
+
Added: plugins/Console/trunk/jcfunc/Description.java
===================================================================
--- plugins/Console/trunk/jcfunc/Description.java (rev 0)
+++ plugins/Console/trunk/jcfunc/Description.java 2012-05-28 15:48:05 UTC (rev 21733)
@@ -0,0 +1,84 @@
+/*
+ * Description.java - storage for some control sequence
+ * :tabSize=8:indentSize=8:noTabs=false:
+ * :folding=explicit:collapseFolds=1:
+ *
+ * Copyright (C) 2012, Artem Bryantsev
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+package jcfunc;
+
+/**
+ Class <code>Description</code> stores data about some control sequence.
+ */
+public class Description
+{
+ /**
+ Index of sequence's first character.
+ */
+ public int bPosition;
+
+ /**
+ Index of character followed after sequence's last character.
+ */
+ public int ePosition;
+
+ /**
+ Control function of sequence.
+ */
+ public CF function;
+
+ /**
+ Parameters of control function, if any.
+ */
+ public int[] parameters = null;
+
+ /**
+ Constructor.
+ @param start index of sequence's first character
+ @param end index of character followed after sequence's last character
+ @param func control function of sequence
+ @param params parameters of control function
+ */
+ public Description(int start, int end, CF func, int[] params)
+ {
+ bPosition = start;
+ ePosition = end;
+ function = func;
+ parameters = params;
+ }
+
+ /**
+ Returns string representation of this object.
+ */
+ public String toString()
+ {
+ StringBuilder str = new StringBuilder();
+
+ str.append(" (")
+ .append(bPosition)
+ .append(", ")
+ .append(ePosition)
+ .append(") [");
+
+ for (int i = 0; i < parameters.length; i++) {
+ str.append( parameters[i] );
+ if (i < parameters.length - 1) str.append(",");
+ }
+
+ return function.toString() + str.append("]").toString();
+ }
+}
Added: plugins/Console/trunk/jcfunc/Sequences.java
===================================================================
--- plugins/Console/trunk/jcfunc/Sequences.java (rev 0)
+++ plugins/Console/trunk/jcfunc/Sequences.java 2012-05-28 15:48:05 UTC (rev 21733)
@@ -0,0 +1,783 @@
+/*
+ * Sequences.java - subsets of control functions, patterns and methods to work with them
+ * :tabSize=8:indentSize=8:noTabs=false:
+ * :folding=explicit:collapseFolds=1:
+ *
+ * Copyright (C) 2012, Artem Bryantsev
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+package jcfunc;
+
+import java.util.Map;
+import java.util.EnumMap;
+import java.lang.String;
+import java.lang.Cloneable;
+import java.lang.StringBuilder;
+
+/**
+ Class <code>Sequencies</code> stores subsets of control functions, patterns
+ and methods to work with them.
+ see <a href="http://www.ecma-international.org/publications/standards/Ecma-048.htm">
+ "Standart ECMA-48 Control functions for coded characters sets"</a>
+ */
+public class Sequences
+{
+ //{{{ C0 enum
+ /** Control function of C0-set */
+ public enum C0 {
+ /** \x00 */
+ NUL,
+
+ /** \x01 */
+ SOH,
+
+ /** \x02 */
+ STX,
+
+ /** \x03 */
+ ETX,
+
+ /** \x04 */
+ EOT,
+
+ /** \x05 */
+ ENQ,
+
+ /** \x06 */
+ ACK,
+
+ /** \x07 */
+ BEL,
+
+ /** \x08 */
+ BS,
+
+ /** \x09 */
+ HT,
+
+ /** \x0A */
+ LF,
+
+ /** \x0B */
+ VT,
+
+ /** \x0C */
+ FF,
+
+ /** \x0D */
+ CR,
+
+ /** \x0E */
+ LS1,
+
+ /** \x0F */
+ LS0,
+
+ /** \x10 */
+ DLE,
+
+ /** \x11 */
+ DC1,
+
+ /** \x12 */
+ DC2,
+
+ /** \x13 */
+ DC3,
+
+ /** \x14 */
+ DC4,
+
+ /** \x15 */
+ NAK,
+
+ /** \x16 */
+ SYN,
+
+ /** \x17 */
+ ETB,
+
+ /** \x18 */
+ CAN,
+
+ /** \x19 */
+ EM,
+
+ /** \x1A */
+ SUB,
+
+ /** \x1B */
+ ESC,
+
+ /** \x1C */
+ IS4,
+
+ /** \x1D */
+ IS3,
+
+ /** \x1E */
+ IS2,
+
+ /** \x1F */
+ IS1
+ }
+ //}}}
+
+ //{{{ C1 enum
+ /** Control function of C1-set */
+ public enum C1 {
+ /** \x42 or \x82 */
+ BPH,
+
+ /** \x43 or \x83 */
+ NBH,
+
+ /** \x45 or \x85 */
+ NEL,
+
+ /** \x46 or \x86 */
+ SSA,
+
+ /** \x47 or \x87 */
+ ESA,
+
+ /** \x48 or \x88 */
+ HTS,
+
+ /** \x49 or \x89 */
+ HTJ,
+
+ /** \x4A or \x8A */
+ VTS,
+
+ /** \x4B or \x8B */
+ PLD,
+
+ /** \x4C or \x8C */
+ PLU,
+
+ /** \x4D or \x8D */
+ RI,
+
+ /** \x4E or \x8E */
+ SS2,
+
+ /** \x4F or \x8F */
+ SS3,
+
+ /** \x50 or \x90 */
+ DCS,
+
+ /** \x51 or \x91 */
+ PU1,
+
+ /** \x52 or \x92 */
+ PU2,
+
+ /** \x53 or \x93 */
+ STS,
+
+ /** \x54 or \x94 */
+ CCH,
+
+ /** \x55 or \x95 */
+ MW,
+
+ /** \x56 or \x96 */
+ SPA,
+
+ /** \x57 or \x97 */
+ EPA,
+
+ /** \x58 or \x98 */
+ SOS,
+
+ /** \x5A or \x9A */
+ SCI,
+
+ /** \x5B or \x9B */
+ CSI,
+
+ /** \x5C or \x9C */
+ ST,
+
+ /** \x5D or \x9D */
+ OSC,
+
+ /** \x5E or \x9E */
+ PM,
+
+ /** \x5F or \x9F */
+ APC
+ }
+ //}}}
+
+ //{{{ Sym enum
+ /** Additional symbols */
+ public enum Sym {
+ /** ' ' */
+ SPCE("\\x20"),
+
+ /** '@' */
+ AT("\\x40"),
+
+ /** 'A' */
+ A_UP("\\x41"),
+
+ /** 'B' */
+ B_UP("\\x42"),
+
+ /** 'C' */
+ C_UP("\\x43"),
+
+ /** 'D' */
+ D_UP("\\x44"),
+
+ /** 'E' */
+ E_UP("\\x45"),
+
+ /** 'F' */
+ F_UP("\\x46"),
+
+ /** 'G' */
+ G_UP("\\x47"),
+
+ /** 'H' */
+ H_UP("\\x48"),
+
+ /** 'I' */
+ I_UP("\\x49"),
+
+ /** 'J' */
+ J_UP("\\x4A"),
+
+ /** 'K' */
+ K_UP("\\x4B"),
+
+ /** 'L' */
+ L_UP("\\x4C"),
+
+ /** 'M' */
+ M_UP("\\x4D"),
+
+ /** 'N' */
+ N_UP("\\x4E"),
+
+ /** 'O' */
+ O_UP("\\x4F"),
+
+ /** 'P' */
+ P_UP("\\x50"),
+
+ /** 'Q' */
+ Q_UP("\\x51"),
+
+ /** 'R' */
+ R_UP("\\x52"),
+
+ /** 'S' */
+ S_UP("\\x53"),
+
+ /** 'T' */
+ T_UP("\\x54"),
+
+ /** 'U' */
+ U_UP("\\x55"),
+
+ /** 'V' */
+ V_UP("\\x56"),
+
+ /** 'W' */
+ W_UP("\\x57"),
+
+ /** 'X' */
+ X_UP("\\x58"),
+
+ /** 'Y' */
+ Y_UP("\\x59"),
+
+ /** 'Z' */
+ Z_UP("\\x5A"),
+
+ /** '[' */
+ QBRR("\\x5B"),
+
+ /** '\' */
+ BKSL("\\x5C"),
+
+ /** ']' */
+ QBRL("\\x5D"),
+
+ /** '^' */
+ CRET("\\x5E"),
+
+ /** '_' */
+ UNLN("\\x5F"),
+
+ /** '`' */
+ INAP("\\x60"),
+
+ /** 'a' */
+ A_DN("\\x61"),
+
+ /** 'b' */
+ B_DN("\\x62"),
+
+ /** 'c' */
+ C_DN("\\x63"),
+
+ /** 'd' */
+ D_DN("\\x64"),
+
+ /** 'e' */
+ E_DN("\\x65"),
+
+ /** 'f' */
+ F_DN("\\x66"),
+
+ /** 'g' */
+ G_DN("\\x67"),
+
+ /** 'h' */
+ H_DN("\\x68"),
+
+ /** 'i' */
+ I_DN("\\x69"),
+
+ /** 'j' */
+ J_DN("\\x6A"),
+
+ /** 'k' */
+ K_DN("\\x6B"),
+
+ /** 'l' */
+ L_DN("\\x6C"),
+
+ /** 'm' */
+ M_DN("\\x6D"),
+
+ /** 'n' */
+ N_DN("\\x6E"),
+
+ /** 'o' */
+ O_DN("\\x6F"),
+
+ /** '|' */
+ STRK("\\x7C"),
+
+ /** '}' */
+ CBRR("\\x7D"),
+
+ /** '~' */
+ TWDL("\\x7E");
+
+ private String symbol;
+
+ private Sym(String sym)
+ {
+ symbol = sym;
+ }
+
+ public String toString()
+ {
+ return symbol;
+ }
+ }
+ //}}}
+
+ //{{{ data members
+ /** Control functions are reprsented in 7-bit code */
+ public static final int MODE_7BIT = 0;
+ /** Control functions are reprsented in 8-bit code */
+ public static final int MODE_8BIT = 1;
+
+ private static final String Pn = "[0-9:]*";
+ private static final String Pn2 = String.format("%s;%s", Pn, Pn);
+ private static final String Pna = String.format("%s(?:;%s)*", Pn, Pn);
+ //}}}
+
+ //{{{ getC0() method
+ private static String[] getC0(C0 key)
+ {
+ switch (key) {
+ case NUL: return new String[] {"\\x00", "\\x00"};
+ case SOH: return new String[] {"\\x01", "\\x01"};
+ case STX: return new String[] {"\\x02", "\\x02"};
+ case ETX: return new String[] {"\\x03", "\\x03"};
+ case EOT: return new String[] {"\\x04", "\\x04"};
+ case ENQ: return new String[] {"\\x05", "\\x05"};
+ case ACK: return new String[] {"\\x06", "\\x06"};
+ case BEL: return new String[] {"\\x07", "\\x07"};
+ case BS : return new String[] {"\\x08", "\\x08"};
+ case HT : return new String[] {"\\x09", "\\x09"};
+ case LF : return new String[] {"\\x0A", "\\x0A"};
+ case VT : return new String[] {"\\x0B", "\\x0B"};
+ case FF : return new String[] {"\\x0C", "\\x0C"};
+ case CR : return new String[] {"\\x0D", "\\x0D"};
+ case LS1: return new String[] {"\\x0E", "\\x0E"};
+ case LS0: return new String[] {"\\x0F", "\\x0F"};
+ case DLE: return new String[] {"\\x10", "\\x10"};
+ case DC1: return new String[] {"\\x11", "\\x11"};
+ case DC2: return new String[] {"\\x12", "\\x12"};
+ case DC3: return new String[] {"\\x13", "\\x13"};
+ case DC4: return new String[] {"\\x14", "\\x14"};
+ case NAK: return new String[] {"\\x15", "\\x15"};
+ case SYN: return new String[] {"\\x16", "\\x16"};
+ case ETB: return new String[] {"\\x17", "\\x17"};
+ case CAN: return new String[] {"\\x18", "\\x18"};
+ case EM : return new String[] {"\\x19", "\\x19"};
+ case SUB: return new String[] {"\\x1A", "\\x1A"};
+ case ESC: return new String[] {"\\x1B", "\\x1B"};
+ case IS4: return new String[] {"\\x1C", "\\x1C"};
+ case IS3: return new String[] {"\\x1D", "\\x1D"};
+ case IS2: return new String[] {"\\x1E", "\\x1E"};
+ case IS1: return new String[] {"\\x1F", "\\x1F"};
+ default:
+ return null;
+ }
+ } //}}}
+
+ //{{{ getC1() method
+ private static String[] getC1(C1 key, String esc)
+ {
+ switch (key) {
+ case BPH: return new String[] {esc + "\\x42", "\\x82"};
+ case NBH: return new String[] {esc + "\\x43", "\\x83"};
+ case NEL: return new String[] {esc + "\\x45", "\\x85"};
+ case SSA: return new String[] {esc + "\\x46", "\\x86"};
+ case ESA: return new String[] {esc + "\\x47", "\\x87"};
+ case HTS: return new String[] {esc + "\\x48", "\\x88"};
+ case HTJ: return new String[] {esc + "\\x49", "\\x89"};
+ case VTS: return new String[] {esc + "\\x4A", "\\x8A"};
+ case PLD: return new String[] {esc + "\\x4B", "\\x8B"};
+ case PLU: return new String[] {esc + "\\x4C", "\\x8C"};
+ case RI : return new String[] {esc + "\\x4D", "\\x8D"};
+ case SS2: return new String[] {esc + "\\x4E", "\\x8E"};
+ case SS3: return new String[] {esc + "\\x4F", "\\x8F"};
+ case DCS: return new String[] {esc + "\\x50", "\\x90"};
+ case PU1: return new String[] {esc + "\\x51", "\\x91"};
+ case PU2: return new String[] {esc + "\\x52", "\\x92"};
+ case STS: return new String[] {esc + "\\x53", "\\x93"};
+ case CCH: return new String[] {esc + "\\x54", "\\x94"};
+ case MW : return new String[] {esc + "\\x55", "\\x95"};
+ case SPA: return new String[] {esc + "\\x56", "\\x96"};
+ case EPA: return new String[] {esc + "\\x57", "\\x97"};
+ case SOS: return new String[] {esc + "\\x58", "\\x98"};
+ case SCI: return new String[] {esc + "\\x5A", "\\x9A"};
+ case CSI: return new String[] {esc + "\\x5B", "\\x9B"};
+ case ST : return new String[] {esc + "\\x5C", "\\x9C"};
+ case OSC: return new String[] {esc + "\\x5D", "\\x9D"};
+ case PM : return new String[] {esc + "\\x5E", "\\x9E"};
+ case APC: return new String[] {esc + "\\x5F", "\\x9F"};
+ default:
+ return null;
+ }
+ } //}}}
+
+ //{{{ getRecordByCF() method
+ private static Record getRecordByCF(CF func)
+ {
+ String ESC = getC0(C0.ESC)[0];
+ String[] CSI = getC1(C1.CSI, ESC);
+ String str = "";
+
+ switch (func) {
+ //{{{ defines functions without parameters
+ case ACK : return new Record( getC0(C0.ACK) );
+ case APC : return new Record( getC1(C1.APC, ESC) );
+ case BEL : return new Record( getC0(C0.BEL) );
+ case BPH : return new Record( getC1(C1.BPH, ESC) );
+ case BS : return new Record( getC0(C0.BS ) );
+ case CAN : return new Record( getC0(C0.CAN) );
+ case CCH : return new Record( getC1(C1.CCH, ESC) );
+ case CR : return new Record( getC0(C0.CR ) );
+ case CSI : return new Record( getC1(C1.CSI, ESC) );
+ case DC1 : return new Record( getC0(C0.DC1) );
+ case DC2 : return new Record( getC0(C0.DC2) );
+ case DC3 : return new Record( getC0(C0.DC3) );
+ case DC4 : return new Record( getC0(C0.DC4) );
+ case DCS : return new Record( getC1(C1.DCS, ESC) );
+ case DLE : return new Record( getC0(C0.DLE) );
+ case EM : return new Record( getC0(C0.EM ) );
+ case ENQ : return new Record( getC0(C0.ENQ) );
+ case EOT : return new Record( getC0(C0.EOT) );
+ case EPA : return new Record( getC1(C1.EPA, ESC) );
+ case ESA : return new Record( getC1(C1.ESA, ESC) );
+ case ESC : return new Record( getC0(C0.ESC) );
+ case ETB : return new Record( getC0(C0.ETB) );
+ case ETX : return new Record( getC0(C0.ETX) );
+ case FF : return new Record( getC0(C0.FF ) );
+ case HT : return new Record( getC0(C0.HT ) );
+ case HTJ : return new Record( getC1(C1.HTJ, ESC) );
+ case HTS : return new Record( getC1(C1.HTS, ESC) );
+ case IS1 : return new Record( getC0(C0.IS1) );
+ case IS2 : return new Record( getC0(C0.IS2) );
+ case IS3 : return new Record( getC0(C0.IS3) );
+ case IS4 : return new Record( getC0(C0.IS4) );
+ case LF : return new Record( getC0(C0.LF ) );
+ case LS0 : return new Record( null, getC0(C0.LS0)[1] );
+ case LS1 : return new Record( null, getC0(C0.LS0)[1] );
+ case MW : return new Record( getC1(C1.MW , ESC) );
+ case NAK : return new Record( getC0(C0.NAK) );
+ case NBH : return new Record( getC1(C1.NBH, ESC) );
+ case NEL : return new Record( getC1(C1.NEL, ESC) );
+ case NUL : return new Record( getC0(C0.NUL) );
+ case OSC : return new Record( getC1(C1.OSC, ESC) );
+ case PLD : return new Record( getC1(C1.PLD, ESC) );
+ case PLU : return new Record( getC1(C1.PLU, ESC) );
+ case PM : return new Record( getC1(C1.PM , ESC) );
+ case PU1 : return new Record( getC1(C1.PU1, ESC) );
+ case PU2 : return new Record( getC1(C1.PU2, ESC) );
+ case RI : return new Record( getC1(C1.RI , ESC) );
+ case SCI : return new Record( getC1(C1.SCI, ESC) );
+ case SI : return new Record( getC0(C0.LS0)[0], null );
+ case SO : return new Record( getC0(C0.LS1)[0], null );
+ case SOH : return new Record( getC0(C0.SOH) );
+ case SOS : return new Record( getC1(C1.SOS, ESC) );
+ case SPA : return new Record( getC1(C1.SPA, ESC) );
+ case SS2 : return new Record( getC1(C1.SS2, ESC) );
+ case SS3 : return new Record( getC1(C1.SS3, ESC) );
+ case SSA : return new Record( getC1(C1.SSA, ESC) );
+ case ST : return new Record( getC1(C1.ST , ESC) );
+ case STS : return new Record( getC1(C1.STS, ESC) );
+ case STX : return new Record( getC0(C0.STX) );
+ case SUB : return new Record( getC0(C0.SUB) );
+ case SYN : return new Record( getC0(C0.SYN) );
+ case VT : return new Record( getC0(C0.VT ) );
+ case VTS : return new Record( getC1(C1.VTS, ESC) );
+ //}}}
+ //{{{ defines functions with any paraeters
+ case CBT : str = Pn + Sym.Z_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CHA : str = Pn + Sym.G_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CHT : str = Pn + Sym.I_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CMD : str = ESC + Sym.D_DN; return new Record(str, str);
+ case CNL : str = Pn + Sym.E_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CPL : str = Pn + Sym.F_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CPR : str = Pn2 + Sym.R_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CTC : str = Pna + Sym.W_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CUB : str = Pn + Sym.D_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CUD : str = Pn + Sym.B_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CUF : str = Pn + Sym.C_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CUP : str = Pn2 + Sym.H_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CUU : str = Pn + Sym.A_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case CVT : str = Pn + Sym.Y_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case DA : str = Pn + Sym.C_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case DAQ : str = Pna + Sym.O_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case DCH : str = Pn + Sym.P_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case DL : str = Pn + Sym.M_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case DMI : str = ESC + Sym.INAP; return new Record(str, str);
+ case DSR : str = Pn + Sym.N_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case DTA : str = Pn2 + Sym.SPCE + Sym.T_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case EA : str = Pn + Sym.O_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case ECH : str = Pn + Sym.X_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case ED : str = Pn + Sym.J_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case EF : str = Pn + Sym.N_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case EL : str = Pn + Sym.K_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case EMI : str = ESC + Sym.B_DN; return new Record(str, str);
+ case FNK : str = Pn + Sym.SPCE + Sym.W_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case FNT : str = Pn2 + Sym.SPCE + Sym.D_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case GCC : str = Pn + Sym.SPCE + Sym.UNLN; return new Record(CSI[0] + str, CSI[1] + str);
+ case GSM : str = Pn2 + Sym.SPCE + Sym.B_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case GSS : str = Pn + Sym.SPCE + Sym.C_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case HPA : str = Pn + Sym.INAP; return new Record(CSI[0] + str, CSI[1] + str);
+ case HPB : str = Pn + Sym.J_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case HPR : str = Pn + Sym.A_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case HVP : str = Pn2 + Sym.F_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case ICH : str = Pn + Sym.AT; return new Record(CSI[0] + str, CSI[1] + str);
+ case IDCS: str = Pn + Sym.SPCE + Sym.O_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case IGS : str = Pn + Sym.SPCE + Sym.M_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case IL : str = Pn + Sym.L_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case INT : str = ESC + Sym.A_DN; return new Record(str, str);
+ case JFY : str = Pna + Sym.SPCE + Sym.F_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case LS1R: str = ESC + Sym.TWDL; return new Record(str, str);
+ case LS2 : str = ESC + Sym.N_DN; return new Record(str, str);
+ case LS2R: str = ESC + Sym.CBRR; return new Record(str, str);
+ case LS3 : str = ESC + Sym.O_DN; return new Record(str, str);
+ case LS3R: str = ESC + Sym.STRK; return new Record(str, str);
+ case MC : str = Pn + Sym.I_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case NP : str = Pn + Sym.U_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PEC : str = Pn + Sym.SPCE + Sym.Z_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PFS : str = Pn + Sym.SPCE + Sym.J_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PP : str = Pn + Sym.V_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PPA : str = Pn + Sym.SPCE + Sym.P_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PPB : str = Pn + Sym.SPCE + Sym.R_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PPR : str = Pn + Sym.SPCE + Sym.Q_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case PTX : str = Pn + Sym.BKSL; return new Record(CSI[0] + str, CSI[1] + str);
+ case QUAD: str = Pna + Sym.SPCE + Sym.H_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case REP : str = Pn + Sym.B_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case RIS : str = ESC + Sym.C_DN; return new Record(str, str);
+ case RM : str = Pna + Sym.L_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SACS: str = Pn + Sym.SPCE + Sym.BKSL; return new Record(CSI[0] + str, CSI[1] + str);
+ case SAPV: str = Pna + Sym.SPCE + Sym.QBRL; return new Record(CSI[0] + str, CSI[1] + str);
+ case SCO : str = Pn + Sym.SPCE + Sym.E_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SCP : str = Pn2 + Sym.SPCE + Sym.K_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SCS : str = Pn + Sym.SPCE + Sym.G_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SD : str = Pn + Sym.T_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SDS : str = Pn + Sym.QBRL; return new Record(CSI[0] + str, CSI[1] + str);
+ case SEE : str = Pn + Sym.Q_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SEF : str = Pn2 + Sym.SPCE + Sym.Y_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SGR : str = Pna + Sym.M_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SHS : str = Pn + Sym.SPCE + Sym.K_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SIMD: str = Pn + Sym.CRET; return new Record(CSI[0] + str, CSI[1] + str);
+ case SL : str = Pn + Sym.SPCE + Sym.AT; return new Record(CSI[0] + str, CSI[1] + str);
+ case SLH : str = Pn + Sym.SPCE + Sym.U_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SLL : str = Pn + Sym.SPCE + Sym.V_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SLS : str = Pn + Sym.SPCE + Sym.H_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SM : str = Pna + Sym.H_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SPD : str = Pn2 + Sym.SPCE + Sym.S_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SPH : str = Pn + Sym.SPCE + Sym.I_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SPI : str = Pn2 + Sym.SPCE + Sym.G_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SPL : str = Pn + Sym.SPCE + Sym.J_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SPQR: str = Pn + Sym.SPCE + Sym.X_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SR : str = Pn + Sym.SPCE + Sym.A_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SRCS: str = Pn + Sym.SPCE + Sym.F_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case SRS : str = Pn + Sym.QBRR; return new Record(CSI[0] + str, CSI[1] + str);
+ case SSU : str = Pn + Sym.SPCE + Sym.I_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SSW : str = Pn + Sym.SPCE + Sym.QBRR; return new Record(CSI[0] + str, CSI[1] + str);
+ case STAB: str = Pn + Sym.SPCE + Sym.CRET; return new Record(CSI[0] + str, CSI[1] + str);
+ case SU : str = Pn + Sym.S_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case SVS : str = Pn + Sym.SPCE + Sym.L_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case TAC : str = Pn + Sym.SPCE + Sym.B_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case TALE: str = Pn + Sym.SPCE + Sym.A_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case TATE: str = Pn + Sym.SPCE + Sym.INAP; return new Record(CSI[0] + str, CSI[1] + str);
+ case TBC : str = Pn + Sym.G_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case TCC : str = Pn2 + Sym.SPCE + Sym.C_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case TSR : str = Pn + Sym.SPCE + Sym.D_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case TSS : str = Pn + Sym.SPCE + Sym.E_UP; return new Record(CSI[0] + str, CSI[1] + str);
+ case VPA : str = Pn + Sym.D_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case VPB : str = Pn + Sym.K_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ case VPR : str = Pn + Sym.E_DN; return new Record(CSI[0] + str, CSI[1] + str);
+ //}}}
+ }
+
+ return null;
+ } //}}}
+
+ //{{{ generateFullWorkingSet() method
+ /** Returns map of Records. Map contains information about ALL control functions. */
+ public static EnumMap<CF, Record> generateFullWorkingSet()
+ {
+ return generateWorkingSet(CF.values());
+ } //}}}
+
+ //{{{ generateWorkingSet() method
+ /**
+ Returns map of Records. Map contains information about SELECTED control functions only.
+ If array of control functions is empty - returned Map is empty too.
+ @param args array of control functions
+ */
+ public static EnumMap<CF, Record> generateWorkingSet(CF... args)
+ {
+ EnumMap<CF, Record> retws = new EnumMap<CF, Record>(CF.ACK.getDeclaringClass());
+
+ for (CF element: args)
+ retws.put( element, getRecordByCF(element) );
+
+ return retws;
+ } //}}}
+
+ //{{{ getCFPattern() method
+ /**
+ Returns control function's RegExp-pattern.
+ @param cmd control function
+ @param mode mode of control function's repersentation @see Sequencies.MODE_7BIT and Sequencies.MODE_8BIT
+ */
+ public static String getCFPattern(CF cmd, int mode)
+ {
+ if (mode == MODE_8BIT) {
+ return getRecordByCF(cmd).pattern8;
+
+ } else {
+ return getRecordByCF(cmd).pattern7;
+
+ }
+ } //}}}
+
+ //{{{ getCommonCFPattern() method
+ /**
+ Returns common control function's RegExp-pattern, which matches any sequence.
+ @param mode mode of control function's repersentation @see Sequencies.MODE_7BIT and Sequencies.MODE_8BIT
+ @param exceptLF_CR enables skipping following symbols: Line Feed ("\u000A") and Carriage Return ("\u000D")
+ */
+ public static String getCommonCFPattern(int mode, boolean exceptLF_CR)
+ {
+ String ESC = "";
+ String c0func = exceptLF_CR ?
+ String.format("[%s-%s&&[^%s%s]]", getC0(C0.NUL)[0], getC0(C0.IS1)[0],
+ getC0(C0.LF )[0], getC0(C0.CR )[0] ) :
+ String.format("[%s-%s]" , getC0(C0.NUL)[0], getC0(C0.IS1)[0] );
+
+ String c1func = mode == MODE_7BIT ?
+ String.format("%s[%s-%s]", getC0(C0.ESC)[0], getC1(C1.BPH, ESC)[0], getC1(C1.APC, ESC)[0] ) :
+ String.format("[%s-%s]" , getC1(C1.BPH, ESC)[1], getC1(C1.APC, ESC)[1] );
+
+ String csi = (mode == MODE_7BIT ?
+ String.format("(?:%s%s|%s)", getC0(C0.ESC)[0], getC1(C1.CSI, ESC)[0], getC0(C0.ESC)[0] ) :
+ String.format("(?:%s|%s)" , getC1(C1.CSI, ESC)[1], getC0(C0.ESC)[1] ) )
+ + Pna
+ + String.format("%s?[%s-%s%s%s%s]", Sym.SPCE, Sym.AT, Sym.O_DN, Sym.STRK, Sym.CBRR, Sym.TWDL);
+
+
+ return String.format("(?:%s)|%s|%s", csi, c0func, c1func);
+ } //}}}
+
+ //{{{ inner Record class
+ /**
+ Class <code>Record</code> stores RegExp-patterns.
+ */
+ public static class Record implements Cloneable
+ {
+ /** 7-bit mode's pattern */
+ public String pattern7;
+ /** 8-bit mode's pattern */
+ public String pattern8;
+
+ /**
+ Constructor.
+ @param str7 7-bit mode's pattern
+ @param str8 8-bit mode's pattern
+ */
+ public Record(String str7, String str8)
+ {
+ pattern7 = str7;
+ pattern8 = str8;
+ }
+
+ /**
+ Constructor.
+ @param strs contains 7- and 8-bit mode's patterns
+ */
+ public Record(String[] strs)
+ {
+ pattern7 = strs[0];
+ pattern8 = strs[1];
+ }
+
+ /** Creates copy of current instance. */
+ public Record clone()
+ {
+ return new Record(pattern7, pattern8);
+ }
+
+ /** Returns string represetation of current instance. */
+ public String toString()
+ {
+ return String.format("%-35s : %-35s", pattern7, pattern8);
+ }
+ }//}}}
+
+} //}}}
+
Added: plugins/Console/trunk/jcfunc/escMatcher.java
===================================================================
--- plugins/Console/trunk/jcfunc/escMatcher.java (rev 0)
+++ plugins/Console/trunk/jcfunc/escMatcher.java 2012-05-28 15:48:05 UTC (rev 21733)
@@ -0,0 +1,325 @@
+/*
+ * escMatcher.java - central class
+ * :tabSize=8:indentSize=8:noTabs=false:
+ * :folding=explicit:collapseFolds=1:
+ *
+ * Copyright (C) 2012, Artem Bryantsev
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+package jcfunc;
+
+import java.util.regex.*;
+import java.util.Map;
+import java.util.EnumMap;
+import java.util.ArrayList;
+
+/**
+ Central class. Its functions are:
+ <ul>
+ <li> matching control function in a text</li>
+ <li> removing control function from the text</li>
+ <li> parsing control functions</li>
+ </ul>
+ Typical invocation sequence is thus:
+ <ol>
+ <li>create: new escMatcher</li>
+ <li>set up working set of control functions (what functions are parsing?): setPatterns()</li>
+ <li>matches() and parse()</li>
+ </ol>
+ */
+public class escMatcher
+{
+//{{{ escMatcher class
+ //{{{ data members
+ private int MATCH_MODE;
+ private int COMPILE_FLAG;
+ private Pattern basePattern; // CF.CSI
+ private Pattern commonPattern; // any CF
+ private Pattern searchPattern; // for matches() method
+ private EnumMap<CF, Pattern> workPatterns = new EnumMap<CF, Pattern>(CF.class); // all except CF.CSI
+ private String DIVIDER = ";";
+ private Pattern replace4spliting = Pattern.compile("[^0-9"+DIVIDER+"]");
+ private CF notFound;
+ //}}}
+
+ //{{{ returnPattern() method
+ private Pattern returnPattern(String str)
+ {
+ return Pattern.compile(str, COMPILE_FLAG);
+ } //}}}
+
+ //{{{ getPositions() method
+ private int[] getPositions(String substr, String str, int startPos)
+ {
+ int[] result = new int[3];
+ int len = substr.length();
+
+
+ result[0] = result[1] = result[2] = str.indexOf(substr, startPos);
+ result[0] += len;
+ result[2] += len;
+
+ return result;
+ } //}}}
+
+ //{{{ constructor
+ /**
+ * Constructor.
+ * @param mode - parsing mode, 7-bit or 8-bit
+ * @param compileFlag - control flags for 'Pattern.compile()' method
+ */
+ public escMatcher(int mode, int compileFlag)
+ {
+ MATCH_MODE = mode;
+ COMPILE_FLAG = compileFlag;
+
+ // init generic patterns
+ basePattern = returnPattern( Sequences.getCFPattern(CF.CSI, MATCH_MODE) );
+ commonPattern = returnPattern( Sequences.getCommonCFPattern(MATCH_MODE, true) );
+ searchPattern = returnPattern(".*?" + Sequences.getCFPattern(CF.CSI, MATCH_MODE) );
+
+ notFound = CF.NUL;
+ } //}}}
+
+ //{{{ setPatterns() method
+ /**
+ * Creates working set of patterns
+ * @param cmds - array of control functions for parsing; if it is absent then all functions are set up
+ */
+ public void setPatterns(CF... cmds)
+ {
+ EnumMap<CF, Sequences.Record> newMap;
+
+ if (cmds == null || cmds.length == 0) {
+ newMap = Sequences.generateFullWorkingSet();
+
+ } else {
+ newMap = Sequences.generateWorkingSet(cmds);
+
+ }
+
+ workPatterns.clear();
+
+ String str;
+ for ( Map.Entry<CF, Sequences.Record> entry: newMap.entrySet() ) {
+ // CF.CSI ? => ignor
+ if (entry.getKey() == CF.CSI) continue;
+
+ if (MATCH_MODE == Sequences.MODE_7BIT) {
+ str = entry.getValue().pattern7;
+
+ } else if (MATCH_MODE == Sequences.MODE_8BIT) {
+ str = entry.getValue().pattern8;
+
+ } else {
+ str = entry.getValue().pattern7;
+
+ }
+
+ // 7bit: CF.LS0 == CF.LS1 == null
+ // 8bit: CF.SI == CF.SO == null
+ if (str != null)
+ workPatterns.put(entry.getKey(), Pattern.compile(str));
+
+ }
+ } //}}}
+
+ //{{{ matches() method
+ /**
+ * This method matches input string with patterns from Working set
+ * @param inputString string for matching
+ * @return true if input string matches this matcher's pattern
+ */
+ public boolean matches(String inputString)
+ {
+ return searchPattern.matcher(inputString).lookingAt();
+ } //}}}
+
+ //{{{ remove() method
+ /**
+ * Remove from input string control function's sequence only.
+ * Substring which followed control function immediately is kept.
+ * @param inputString input string
+ * @param func removed control function
+ * @return string without stated control function
+ */
+ public String remove(String inputString, CF func)
+ {
+ if ( !workPatterns.isEmpty() && workPatterns.containsKey(func) ) {
+ return workPatterns.get(func).matcher(inputString).replaceAll("");
+ } else {
+ return inputString;
+ }
+ } //}}}
+
+ //{{{ removeAll() method
+ /**
+ * Remove from input string any control function's sequence only.
+ * Substring which followed control function immediately is kept.
+ * @param inputString input string
+ * @return string without any stated control functions
+ */
+ public String removeAll(String inputString)
+ {
+ return commonPattern.matcher(inputString).replaceAll("");
+ } //}}}
+
+ //{{{ parse() method
+ /**
+ Main method. It returns:
+ <ul>
+ <li>found control function (CF)</li>
+ <li>index of CF's first symbol (usually it's CF.CSI)</li>
+ <li>offset after the last character matched (after end of substring)</li>
+ <li>int-array of CF's parameters, if any</li>
+ </ul>
+ @param inputString parsed string
+ @return array list of Description's objects
+ */
+ public ArrayList<Description> parse(String inputString)
+ {
+ return parse(inputString, false);
+ } //}}}
+
+ //{{{ parse() method
+ /**
+ Main method.
+ If <code>ignorSequences</code> is set FALSE then final indecies describe substrings
+ WITH control functions and their parameters. Otherwise (TRUE) substrings
+ include substrings (data) only.
+ @param inputString parsed string
+ @param ignorSequences affects to returned indecies
+ @return array list of Description's objects
+ */
+ public ArrayList<Description> parse(String inputString, boolean ignorSequences)
+ {
+ if (workPatterns == null || workPatterns.isEmpty() )
+ return null;
+
+ ArrayList<Description> returnedList = null;
+ ArrayList<String> internalList = new ArrayList<String>();
+
+ /* looks for any sequences */
+ Matcher matcher = basePattern.matcher(inputString);
+
+ int prevBegining = -1;
+ while ( matcher.find() ) {
+ int newBegining = matcher.start();
+
+ if (prevBegining != -1)
+ internalList.add( inputString.substring(prevBegining, newBegining) );
+
+ prevBegining = newBegining;
+ }
+ if (prevBegining != -1)
+ internalList.add( inputString.substring(prevBegining) );
+
+ /* process found strings */
+ if ( !internalList.isEmpty() ) {
+ returnedList = new ArrayList<Description>( internalList.size() );
+
+ if (ignorSequences)
+ inputString = removeAll(inputString);
+
+ int position = 0;
+
+ // go over strings
+ for ( String processingStr: internalList ) {
+
+ CF foundCF = null;
+ matcher = null;
+
+ // go over patterns
+ for ( Map.Entry<CF, Pattern> pattern: workPatterns.entrySet() ) {
+
+ matcher = pattern.getValue().matcher(processingStr);
+
+ if ( matcher.lookingAt() ) {
+ foundCF = pattern.getKey();
+ break;
+ }
+ }
+
+ // it's unknowned sequence (it's absent in 'workPatterns')
+ if (foundCF == null) {
+ foundCF = notFound;
+ matcher = null;
+ }
+
+ int[] params;
+ int[] result = {0, 0, 0};
+
+ if (matcher != null) {
+ /* extracts parameters from the substring
+ *
+ * ESC[01;34;45m_substring
+ * ^ ^
+ * | |
+ * matcher.start() matcher.end()
+ */
+
+ // splits string to array
+ int end = matcher.end();
+ String[] strArr =
+ replace4spliting.matcher(
+ // removes CF.CSI : "01;34;45m"
+ basePattern.matcher(
+ // extracts sequence : ^-- "ESC[01;34;45m"
+ processingStr.substring( matcher.start(), end )
+ ).replaceAll("")
+ ).replaceAll(DIVIDER).split(DIVIDER, 0);
+ // converting
+ params = new int[strArr.length];
+ for (int i = 0; i < strArr.length; i++)
+ params[i] = Integer.decode(strArr[i]);
+
+ if (ignorSequences) {
+ if ( end < processingStr.length() ) {
+ result = getPositions(processingStr.substring(end), inputString, position);
+
+ } else {
+ result[1] = result[2] = position;
+ }
+
+ } else {
+ result = getPositions(processingStr, inputString, position);
+
+ }
+
+ } else {
+ params = new int[0];
+
+ if (ignorSequences) {
+ result = getPositions(removeAll(processingStr), inputString, position);
+
+ } else {
+ result = getPositions(processingStr, inputString, position);
+
+ }
+
+ }
+
+ position = result[0];
+
+ returnedList.add( new Description(result[1], result[2], foundCF, params) );
+ }
+ }
+
+ return returnedList;
+ } //}}}
+
+ //}}}
+}
Added: plugins/Console/trunk/jcfunc/parameters/paramSGR.java
===================================================================
--- plugins/Console/trunk/jcfunc/parameters/paramSGR.java (rev 0)
+++ plugins/Console/trunk/jcfunc/parameters/paramSGR.java 2012-05-28 15:48:05 UTC (rev 21733)
@@ -0,0 +1,322 @@
+/*
+ * paramSGR.java - returned values for CF.SGR
+ * :tabSize=8:indentSize=8:noTabs=false:
+ * :folding=explicit:collapseFolds=1:
+ *
+ * Copyright (C) 2012, Artem Bryantsev
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+package jcfunc.parameters;
+
+import java.awt.Color;
+
+/**
+ Enum <code>paramSGR</code> contains returned values for control function CF.SGR
+ and some methods, which are designed to thus values processing.
+ Additionally it contains Color-parsing method.
+ */
+public enum paramSGR
+{
+ //{{{ enum's values
+ /** default rendition (implementation-defined), cancels the effect of any preceding occurrence of SGR in
+ the data stream regardless of the setting of the GRAPHIC RENDITION COMBINATION MODE (GRCM) */
+ Reset(0),
+
+ /** bold or increased intensity */
+ Bright(1),
+
+ /** faint, decreased intensity or second colour */
+ Faint(2),
+
+ /** italicized */
+ Italic(3),
+
+ /** singly underlined */
+ Underline_Single(4),
+
+ /** slowly blinking (less then 150 per minute) */
+ Blink_Slow(5),
+
+ /** rapidly blinking (150 per minute or more) */
+ Blink_Rapid(6),
+
+ /** negative image */
+ Image_NGT(7),
+
+ /** concealed characters */
+ Conceal(8),
+
+ /** crossed-out (characters still legible but marked as to be deleted) */
+ CrossedOut(9),
+
+ /** primary (default) font */
+ Font_Pimary(10),
+
+ /** first alternative font */
+ Font_Alt1(11),
+
+ /** second alternative font */
+ Font_Alt2(12),
+
+ /** third alternative font */
+ Font_Alt3(13),
+
+ /** fourth alternative font */
+ Font_Alt4(14),
+
+ /** fifth alternative font */
+ Font_Alt5(15),
+
+ /** sixth alternative font */
+ Font_Alt6(16),
+
+ /** seventh alternative font */
+ Font_Alt7(17),
+
+ /** eighth alternative font */
+ Font_Alt8(18),
+
+ /** ninth alternative font */
+ Font_Alt9(19),
+
+ /** Fraktur (Gothic) */
+ Fraktur(20),
+
+ /** doubly underlined */
+ Underline_Doubly(21),
+
+ /** normal colour or normal intensity (neither bold nor faint) */
+ Normal_Int(22),
+
+ /** not italicized, not fraktur */
+ Normal_Style(23),
+
+ /** not underlined (neither singly nor doubly) */
+ Underline_NGT(24),
+
+ /** steady (not blinking) */
+ Blink_NGT(25),
+
+ /** (reserved for proportional spacing as specified in CCITT Recommendation T.61) */
+ Reserved_1(26),
+
+ /** positive image */
+ Image_PST(27),
+
+ /** revealed characters */
+ Reveal(28),
+
+ /** not crossed out */
+ CrossedOut_NGT(29),
+
+ /** black display */
+ Color_Text_Black(30),
+
+ /** red display */
+ Color_Text_Red(31),
+
+ /** green display */
+ Color_Text_Green(32),
+
+ /** yellow display */
+ Color_Text_Yellow(33),
+
+ /** blue display */
+ Color_Text_Blue(34),
+
+ /** magenta display */
+ Color_Text_Magenta(35),
+
+ /** cyan display */
+ Color_Text_Cyan(36),
+
+ /** white display */
+ Color_Text_White(37),
+
+ /** (reserved for future standardization; intended for setting character foreground
+ colour as specified in ISO 8613-6 [CCITT Recommendation T.416]) */
+ Color_Text_Reserved(38),
+
+ /** default display colour (implementation-defined) */
+ Color_Text_Reset(39),
+
+ /** black background */
+ Color_Bkgr_Black(40),
+
+ /** red background */
+ Color_Bkgr_Red(41),
+
+ /** green background */
+ Color_Bkgr_Green(42),
+
+ /** yellow background */
+ Color_Bkgr_Yellow(43),
+
+ /** blue background */
+ Color_Bkgr_Blue(44),
+
+ /** magenta background */
+ Color_Bkgr_Magenta(45),
+
+ /** cyan background */
+ Color_Bkgr_Cyan(46),
+
+ /** white background */
+ Color_Bkgr_White(47),
+
+ /** (reserved for future standardization; intended for setting character background
+ colour as specified in ISO 8613-6 [CCITT Recommendation T.416]) */
+ Color_Bkgr_Reserved(48),
+
+ /** default background colour (implementation-defined) */
+ Color_Bkgr_Reset(49),
+
+ /** (reserved for cancelling the effect of the rendering aspect established by parameter value 26) */
+ Reserved_2(50),
+
+ /** framed */
+ Framed(51),
+
+ /** encircled */
+ Encircled(52),
+
+ /** overlined */
+ Overlined(53),
+
+ /** not framed, not encircled */
+ Outlined_NGT(54),
+
+ /** not overlined */
+ Overlined_NGT(55),
+
+ /** (reserved for future standardization) */
+ Reserved_3(56),
+
+ /** (reserved for future standardization) */
+ Reserved_4(57),
+
+ /** (reserved for future standardization) */
+ Reserved_5(58),
+
+ /** (reserved for future standardization) */
+ Reserved_6(59),
+
+ /** ideogram underline or right side line */
+ Line_BottomOrRight_Single(60),
+
+ /** ideogram double underline or double line on the right side */
+ Line_BottomOrRight_Double(61),
+
+ /** ideogram overline or left side line */
+ Line_TopOrLeft_Single(62),
+
+ /** ideogram double overline or double line on the left side */
+ Line_TopOrLeft_Double(63),
+
+ /** ideogram stress marking */
+ Stress_Mark(64),
+
+ /** cancels the effect of the rendition aspects established by parameter values 60 to 64 */
+ Cansel_Any_Line(65),
+
+ /** Don't define in Standart */
+ Nonstandard(-1);
+ //}}}
+
+ private int value;
+
+ paramSGR(int value)
+ {
+ this.value = value;
+ }
+
+ //{{{ getIntValue() method
+ /**
+ Returns int-value, which is corresponded to enum-value.
+ @param val enum-value
+ @return int-value
+ */
+ public static int getIntValue(paramSGR val)
+ {
+ return val.value;
+ } //}}}
+
+ //{{{ getEnumValue() method
+ /**
+ Returns enum-value by int-value.
+ @param val int-value
+ @return enum-value
+ */
+ public static paramSGR getEnumValue(int val)
+ {
+ for ( paramSGR element: values() )
+ if (element.value == val)
+ return element;
+
+ return Nonstandard;
+ } //}}}
+
+ //{{{ getColor() method
+ /**
+ Translates enum-value to <code>Color</code>.
+ @param val enum-value
+ @return Color-instance
+ */
+ public static Color getColor(paramSGR val)
+ {
+ switch (val)
+ {
+ case Color_Text_Black:
+ case Color_Bkgr_Black:
+ return Color.BLACK;
+
+ case Color_Text_Red:
+ case Color_Bkgr_Red:
+ return Color.RED;
+
+ case Color_Text_Green:
+ case Color_Bkgr_Green:
+ return Color.GREEN;
+
+ case Color_Text_Yellow:
+ case Color_Bkgr_Yellow:
+ return Color.YELLOW;
+
+ case Color_Text_Blue:
+ case Color_Bkgr_Blue:
+ return Color.BLUE;
+
+ case Color_Text_Magenta:
+ case Color_Bkgr_Magenta:
+ return Color.MAGENTA;
+
+ case Color_Text_Cyan:
+ case Color_Bkgr_Cyan:
+ return Color.CYAN;
+
+ case Color_Text_White:
+ case Color_Bkgr_White:
+ return Color.WHITE;
+
+ case Color_Text_Reserved:
+ case Color_Bkgr_Reserved:
+ return null;
+
+ default:
+ return null;
+ }
+ } //}}}
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|