How to add New Language

Questions on using RSyntaxTextArea should go here.

Moderator: robert

How to add New Language

Postby Guest » Fri May 31, 2013 5:30 am

Hello,
I'm trying to add a new language to RSyntaxTextArea using JFlex lexer. The lexer is designed for Octave. My flex file is:
Code: Select all
package org.fife.ui.rsyntaxtextarea.modes;

import java.io.*;
import javax.swing.text.Segment;

import org.fife.ui.rsyntaxtextarea.AbstractJFlexTokenMaker;
import org.fife.ui.rsyntaxtextarea.DefaultToken;
import org.fife.ui.rsyntaxtextarea.Token;
import org.fife.ui.rsyntaxtextarea.TokenMaker;



%%

%public
%class OctaveTokenMaker
%extends AbstractJFlexTokenMaker
%implements TokenMaker
%unicode
%type org.fife.ui.rsyntaxtextarea.Token


%{


   public OctaveTokenMaker() {
      super();
   }



   private void addToken(int tokenType) {
      addToken(zzStartRead, zzMarkedPos-1, tokenType);
   }


   
   private void addToken(int start, int end, int tokenType) {
      int so = start + offsetShift;
      addToken(zzBuffer, start,end, tokenType, so);
   }


   
   public void addToken(char[] array, int start, int end, int tokenType, int startOffset) {
      super.addToken(array, start,end, tokenType, startOffset);
      zzStartRead = zzMarkedPos;
   }



   public String[] getLineCommentStartAndEnd() {
      return new String[] { "#", null };
   }



   public Token getTokenList(Segment text, int initialTokenType, int startOffset) {

      resetTokenList();
      this.offsetShift = -text.offset + startOffset;

      // Start off in the proper state.
      int state = Token.NULL;
      switch (initialTokenType) {
         case Token.LITERAL_STRING_DOUBLE_QUOTE:
            state = LONG_STRING_2;
            break;
         case Token.LITERAL_CHAR:
            state = LONG_STRING_1;
            break;
         default:
            state = Token.NULL;
      }

      s = text;
      try {
         yyreset(zzReader);
         yybegin(state);
         return yylex();
      } catch (IOException ioe) {
         ioe.printStackTrace();
         return new DefaultToken();
      }

   }



   public final void yyreset(java.io.Reader reader) throws java.io.IOException {
      // 's' has been updated.
      zzBuffer = s.array;
      /*
       * We replaced the line below with the two below it because zzRefill
       * no longer "refills" the buffer (since the way we do it, it's always
       * "full" the first time through, since it points to the segment's
       * array).  So, we assign zzEndRead here.
       */
      //zzStartRead = zzEndRead = s.offset;
      zzStartRead = s.offset;
      zzEndRead = zzStartRead + s.count - 1;
      zzCurrentPos = zzMarkedPos = zzPushbackPos = s.offset;
      zzLexicalState = YYINITIAL;
      zzReader = reader;
      zzAtBOL  = true;
      zzAtEOF  = false;
   }


   private boolean zzRefill() throws java.io.IOException {
      return zzCurrentPos>=s.offset+s.count;
   }


%}


identifier      = (({letter}|"_")({letter}|{digit}|"_")*)
letter         = ({lowercase}|{uppercase})
lowercase         = ([a-z])
uppercase         = ([A-Z])
digit         = ([0-9])
stringliteral      = ({stringprefix}?{shortstring})
stringprefix      = ("r"|"u"[rR]?|"R"|"U"[rR]?)
shortstring      = ([\"]{shortstring2item}*[\"]?)
shortstring1item   = ({shortstring1char}|{escapeseq})
shortstring2item   = ({shortstring2char}|{escapeseq})
shortstring1char   = ([^\\\n\'])
shortstring2char   = ([^\\\n\"])
escapeseq         = ([\\].)
longinteger      = ({integer}[lL])
integer         = ({decimalinteger}|{octinteger}|{hexinteger})
decimalinteger      = ({nonzerodigit}{digit}*|"0")
octinteger      = ("0"{octdigit}+)
hexinteger      = ("0"[xX]{hexdigit}+)
nonzerodigit      = ([1-9])
octdigit         = ([0-7])
hexdigit         = ({digit}|[a-f]|[A-F])
floatnumber      = ({pointfloat}|{exponentfloat})
pointfloat      = ({intpart}?{fraction}|{intpart}".")
exponentfloat      = (({intpart}|{pointfloat}){exponent})
intpart         = ({digit}+)
fraction         = ("."{digit}+)
exponent         = ([eE][\+\-]?{digit}+)
imagnumber      = (({floatnumber}|{intpart})[jJ])

ErrorNumberFormat   = ({digit}{NonSeparator}+)
NonSeparator      = ([^\t\f\r\n\ \(\)\{\}\[\]\;\,\.\=\>\<\!\~\?\:\+\-\*\/\&\|\^\%\"\']|"#")

LongStringStart1   = ({stringprefix}?\'\'\')
LongStringStart2   = ({stringprefix}?\"\"\")

LineTerminator      = (\n)
WhiteSpace      = ([ \t\f])

LineComment      = ("#".*)


%state LONG_STRING_2


%%

/* Keywords */
<YYINITIAL> "break"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "case"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "catch"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "continue"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "do"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "else"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "elseif"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "end"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "end_try_catch"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "end_unwind_protect"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "endfor"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "endif"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "endparfor"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "endswitch"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "endwhile"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "for"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "function"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "global"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "if"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "otherwise"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "parfor"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "persist"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "return"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "static"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "switch"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "try"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "until"            { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "unwind_protect"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "unwind_protect_cleanup"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "varargin"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "varargout"               { addToken(Token.RESERVED_WORD); }
<YYINITIAL> "while"               { addToken(Token.RESERVED_WORD); }

/* Data types. */
<YYINITIAL> "char"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "double"            { addToken(Token.DATA_TYPE); }
<YYINITIAL> "int"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "cell"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "class"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "int8"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "int16"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "int32"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "int64"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "uint8"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "uint16"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "uint32"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "uint64"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "sparse"               { addToken(Token.DATA_TYPE); }
<YYINITIAL> "struct"               { addToken(Token.DATA_TYPE); }

/* Standard functions */
<YYINITIAL> "amd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "balance"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "besselj"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "betainc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bsxfun"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ccolamd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cellfun"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chol"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "colamd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rat"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "repmat"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rot90"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rotdim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "saveobj"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "shift"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "shiftdim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sortrows"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sph2cart"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "structfun"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "subsindex"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "trapz"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "triplequad"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "convhull"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "delaunay"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "delaunay3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "delaunayn"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dsearch"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "print_usage"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "type"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unimplemented"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "which"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "autumn"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bone"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "brighten"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "colormap"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "contrast"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cool"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isdefinite"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ishermitian"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "issymmetric"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "krylov"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logm"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "normest"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "null"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "onenormest"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "orth"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "planerot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "qzhess"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rank"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "subspace"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "trace"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "vech"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ans"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bincoeff"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bug_report"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bunzip2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bzip2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cast"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "comma"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "compare_versions"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "computer"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "copyfile"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "debug"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "delete"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dir"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dos"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dump_prefs"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "edit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fact"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fileattrib"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fileparts"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fullfile"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "getappdata"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "getfield"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gunzip"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gzip"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "info"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "inputname"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isappdata"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isdeployed"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ismac"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ispc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isunix"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "license"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "list_primes"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "symvar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tempdir"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tempname"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unix"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unpack"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "untar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unzip"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "usejava"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ver"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "version"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "warning_ids"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "what"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "xor"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "zip"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fminbnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fminunc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fsolve"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fzero"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "glpk"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "lsqnonneg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "optimget"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "optimset"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pqpnonneg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "qp"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sqp"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "matlabroot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pathdef"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "savepath"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pkg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "allchild"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ancestor"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "area"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "axes"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "axis"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "barh"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "box"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "caxis"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cla"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "clabel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "clf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "close"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "closereq"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "colorbar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "colstyle"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "comet"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "comet3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "compass"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "contour"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "contour3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "contourc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "contourf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cylinder"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "daspect"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "diffuse"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ellipsoid"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "errorbar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezcontour"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezcontourf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezmesh"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezmeshc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezplot3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezpolar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezsurf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ezsurfc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "feather"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "figure"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fill"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "findall"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "findobj"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gca"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gcbf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gcbo"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gcf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ginput"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gnuplot_binary"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "graphics_toolkit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "grid"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gtext"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "guidata"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "guihandles"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hggroup"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hidden"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hist"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hold"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isfigure"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ishghandle"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ishold"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isocolors"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isonormals"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isosurface"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isprop"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "legend"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "line"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "linkprop"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "loglog"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "loglogerr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mesh"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "meshc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "meshgrid"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "meshz"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ndgrid"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "newplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "orient"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pareto"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "patch"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pbaspect"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pcolor"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "peaks"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pie"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pie3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "plot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "plot3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "plotmatrix"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "plotyy"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polar"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "print"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "quiver"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "quiver3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rectangle"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "refresh"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "refreshdata"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ribbon"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rose"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "saveas"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "scatter"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "scatter3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "semilogx"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "semilogxerr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "semilogy"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "semilogyerr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "shading"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "shg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "slice"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sombrero"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "specular"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sphere"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spinmap"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stairs"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stem"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stem3"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "subplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "surf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "surface"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "surfc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "surfl"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "surfnorm"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "text"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "title"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "trimesh"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "triplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "trisurf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "uicontextmenu"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "uicontrol"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "whitebg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "xlabel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "xlim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ylabel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ylim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "zlabel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "zlim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "compan"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "conv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "deconv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mkpp"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mpoles"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pchip"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "poly"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyaffine"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyder"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyfit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polygcd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyint"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyout"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyreduce"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyval"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "polyvalm"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ppder"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ppint"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ppjumps"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ppval"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "residue"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "roots"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spline"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unmkpp"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "addpref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "getpref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ispref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rmpref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "setpref"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "intersect"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ismember"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "powerset"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "setdiff"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "setxor"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "union"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unique"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "arch_fit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "arch_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "arch_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "arma_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "autoreg_matrix"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bartlett"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "blackman"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "detrend"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "diffpara"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "durbinlevinson"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fftconv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fftfilt"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fftshift"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "filter2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fractdiff"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "freqz"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "freqz_plot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hamming"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hanning"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hurst"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ifftshift"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "periodogram"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sinc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sinetone"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sinewave"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spectral_adf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spectral_xdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spencer"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stft"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "synthesis"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unwrap"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "yulewalker"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bicg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bicgstab"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cgs"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "colperm"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "etreeplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gmres"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nonzeros"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pcg"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pcr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spaugment"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spconvert"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spdiags"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "speye"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spfun"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spones"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sprand"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sprandn"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sprandsym"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spstats"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spy"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "svds"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "treelayout"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "treeplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bessel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "beta"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "betaln"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "factor"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "factorial"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isprime"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "lcm"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "legendre"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nchoosek"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nthroot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "perms"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pow2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "primes"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "reallog"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "realpow"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "realsqrt"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hadamard"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hankel"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hilb"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "invhilb"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "magic"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "pascal"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rosser"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "toeplitz"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "vander"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wilkinson"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "center"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cloglog"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "corr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cov"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gls"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "histc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "iqr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kendall"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kurtosis"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mahalanobis"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mean"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "meansq"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "median"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mode"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "moment"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ols"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ppplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "prctile"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "probit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "qqplot"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "quantile"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "range"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "ranks"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "run_count"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "runlength"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "skewness"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "spearman"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "statistics"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cauchy_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cauchy_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cauchy_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cauchy_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chi2cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chi2inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chi2pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chi2rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "discrete_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "discrete_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "discrete_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "discrete_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "empirical_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "empirical_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "empirical_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "empirical_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "expcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "expinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "exppdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "exprnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "finv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "frnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gamcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gaminv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gampdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "gamrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "geocdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "geoinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "geopdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "geornd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hygecdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hygeinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hygepdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hygernd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kolmogorov_smirnov_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "laplace_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "laplace_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "laplace_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "laplace_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logistic_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logistic_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logistic_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logistic_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logncdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logninv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "lognpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "lognrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nbincdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nbininv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nbinpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "nbinrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "normcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "norminv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "normpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "normrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "poisscdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "poissinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "poisspdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "poissrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stdnormal_cdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stdnormal_inv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stdnormal_pdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "stdnormal_rnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "tpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "trnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unidcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unidinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unidpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unidrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unifcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unifinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unifpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "unifrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wblcdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wblinv"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wblpdf"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wblrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wienrnd"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "logistic_regression"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "anova"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bartlett_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chisquare_test_homogeneity"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "chisquare_test_independence"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cor_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "f_test_regression"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hotelling_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hotelling_test_2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kolmogorov_smirnov_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kolmogorov_smirnov_test_2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "kruskal_wallis_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "manova"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mcnemar_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "prop_test_2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "run_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "sign_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "t_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "t_test_2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "t_test_regression"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "u_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "var_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "welch_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "wilcoxon_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "z_test"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "z_test_2"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "base2dec"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "bin2dec"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "blanks"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "cstrcat"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "deblank"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dec2base"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dec2bin"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "dec2hex"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "findstr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "hex2dec"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "index"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isletter"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "isstrprop"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "mat2str"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "regexptranslate"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rindex"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "str2num"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strcat"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strchr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strjust"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strmatch"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strsplit"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strtok"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strtrim"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "strtrunc"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "substr"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "untabify"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "validatestring"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "assert"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "demo"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "example"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "fail"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "rundemos"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "runtests"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "speed"                 { addToken(Token.FUNCTION); }
<YYINITIAL> "test"                 { addToken(Token.FUNCTION); }

<YYINITIAL> {

   {LineTerminator}            { addNullToken(); return firstToken; }

   {identifier}               { addToken(Token.IDENTIFIER); }

   {WhiteSpace}+               { addToken(Token.WHITESPACE); }

   /* String/Character Literals. */
   {stringliteral}            { addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
   {LongStringStart2}            { yybegin(LONG_STRING_2); addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }

   /* Comment Literals. */
   {LineComment}               { addToken(Token.COMMENT_EOL); }

   /* Separators. */
   "("                     { addToken(Token.SEPARATOR); }
   ")"                     { addToken(Token.SEPARATOR); }
   "["                     { addToken(Token.SEPARATOR); }
   "]"                     { addToken(Token.SEPARATOR); }
   "{"                     { addToken(Token.SEPARATOR); }
   "}"                     { addToken(Token.SEPARATOR); }

   /* Operators. */
   "="                     { addToken(Token.OPERATOR); }
   "+"                     { addToken(Token.OPERATOR); }
   "-"                     { addToken(Token.OPERATOR); }
   "*"                     { addToken(Token.OPERATOR); }
   "/"                     { addToken(Token.OPERATOR); }
   "%"                     { addToken(Token.OPERATOR); }
   "**"                     { addToken(Token.OPERATOR); }
   "~"                     { addToken(Token.OPERATOR); }
   "<"                     { addToken(Token.OPERATOR); }
   ">"                     { addToken(Token.OPERATOR); }
   "<<"                     { addToken(Token.OPERATOR); }
   ">>"                     { addToken(Token.OPERATOR); }
   "=="                     { addToken(Token.OPERATOR); }
   "+="                     { addToken(Token.OPERATOR); }
   "-="                     { addToken(Token.OPERATOR); }
   "*="                     { addToken(Token.OPERATOR); }
   "/="                     { addToken(Token.OPERATOR); }
   "%="                     { addToken(Token.OPERATOR); }
   ">>="                  { addToken(Token.OPERATOR); }
   "<<="                  { addToken(Token.OPERATOR); }
   "^"                     { addToken(Token.OPERATOR); }
   "&"                     { addToken(Token.OPERATOR); }
   "&&"                     { addToken(Token.OPERATOR); }
   "|"                     { addToken(Token.OPERATOR); }
   "||"                     { addToken(Token.OPERATOR); }
   "?"                     { addToken(Token.OPERATOR); }
   ":"                     { addToken(Token.OPERATOR); }
   ","                     { addToken(Token.OPERATOR); }
   "!"                     { addToken(Token.OPERATOR); }
   "++"                     { addToken(Token.OPERATOR); }
   "--"                     { addToken(Token.OPERATOR); }
   "."                     { addToken(Token.OPERATOR); }
   ","                     { addToken(Token.OPERATOR); }
   
   /* Numbers */
   {longinteger}|{integer}         { addToken(Token.LITERAL_NUMBER_DECIMAL_INT); }
   {floatnumber}|{imagnumber}      { addToken(Token.LITERAL_NUMBER_FLOAT); }
   {ErrorNumberFormat}            { addToken(Token.ERROR_NUMBER_FORMAT); }

   /* Other punctuation, we'll highlight it as "identifiers." */
   "@"                     { addToken(Token.IDENTIFIER); }
   ";"                     { addToken(Token.IDENTIFIER); }

   /* Ended with a line not in a string or comment. */
   <<EOF>>                  { addNullToken(); return firstToken; }

   /* Catch any other (unhandled) characters and flag them as bad. */
   .                     { addToken(Token.ERROR_IDENTIFIER); }

}


<LONG_STRING_2> {
   [^\"]+                  { addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
   \"\"\"                  { yybegin(YYINITIAL); addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
   \"                     { addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
   <<EOF>>                  {
                           if (firstToken==null) {
                              addToken(Token.LITERAL_STRING_DOUBLE_QUOTE);
                           }
                           return firstToken;
                        }
}

I generated this a java file using jflex 1.4.1

Edited TokenMakerFactory like this:
Code: Select all
putMapping(SYNTAX_STYLE_OCTAVE,         pkg + "OctaveTokenMaker");

Finally added is this lexer as
Code: Select all
      textArea.setSyntaxEditingStyle(SyntaxConstants.SYNTAX_STYLE_OCTAVE);
 InputStream in = getClass().getResourceAsStream("/vs.xml");
         try {
            Theme theme = Theme.load(in);
            theme.apply(textArea);
         } catch (IOException ioe) {
            ioe.printStackTrace();
         }
     
     

Then I run app,but I got only a default text syntax. it does not display any colored text.
Guest
 

Re: How to add New Language

Postby robert » Fri May 31, 2013 1:05 pm

Sounds like either pkg + "OctaveTokenMaker" isn't the right fully qualified class name, or somehow your OctaveTokenMaker isn't on your classpath. RSTA will fallback to plain text if it doesn't find the TokenMaker class you specified. Try setting a breakpoint in AbstractTokenMakerFactory.getTokenMakerImpl(String) to see what's going on.
User avatar
robert
 
Posts: 788
Joined: Sat May 10, 2008 5:16 pm

Re: How to add New Language

Postby Guest » Sat Jun 01, 2013 2:20 am

Yes, you are right! It works! Thanks
Guest
 


Return to Help

Who is online

Users browsing this forum: No registered users and 1 guest

cron