// DO NOT EDIT
   // Generated by JFlex 1.9.1 http://jflex.de/
   // source: src/main/jflex/testpanel/er7.flex
   
   package testpanel;
   
   import jsyntaxpane.lexers.*;
   import jsyntaxpane.Token;
   import jsyntaxpane.TokenType;
  
  
  @SuppressWarnings("fallthrough")
  public final class Er7Lexer extends DefaultJFlexLexer {
  
    /** This character denotes the end of file. */
    public static final int YYEOF = -1;
  
    /** Initial size of the lookahead buffer. */
    private static final int ZZ_BUFFERSIZE = 16384;
  
    // Lexical states.
    public static final int YYINITIAL = 0;
    public static final int AT_START_OF_VALUE = 2;
    public static final int WITHIN_VALUE = 4;
    public static final int AT_DELIM = 6;
  
    /**
     * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
     * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
     *                  at the beginning of a line
     * l is of the form l = 2*k, k a non negative integer
     */
    private static final int ZZ_LEXSTATE[] = {
       0,  0,  1,  1,  2,  2,  3, 3
    };
  
    /**
     * Top-level table for translating characters to character classes
     */
    private static final int [] ZZ_CMAP_TOP = zzUnpackcmap_top();
  
    private static final String ZZ_CMAP_TOP_PACKED_0 =
      "\1\0\1\u0100\36\u0200\1\u0300\267\u0200\10\u0400\u1020\u0200";
  
    private static int [] zzUnpackcmap_top() {
      int [] result = new int[4352];
      int offset = 0;
      offset = zzUnpackcmap_top(ZZ_CMAP_TOP_PACKED_0, offset, result);
      return result;
    }
  
    private static int zzUnpackcmap_top(String packed, int offset, int [] result) {
      int i = 0;       /* index in packed string  */
      int j = offset;  /* index in unpacked array */
      int l = packed.length();
      while (i < l) {
        int count = packed.charAt(i++);
        int value = packed.charAt(i++);
        do result[j++] = value; while (--count > 0);
      }
      return j;
    }
  
  
    /**
     * Second-level tables for translating characters to character classes
     */
    private static final int [] ZZ_CMAP_BLOCKS = zzUnpackcmap_blocks();
  
    private static final String ZZ_CMAP_BLOCKS_PACKED_0 =
      "\12\0\1\1\2\2\1\3\22\0\1\4\2\0\1\5"+
      "\2\0\1\6\6\0\1\7\1\10\1\0\12\11\7\0"+
      "\7\12\1\13\4\12\1\14\5\12\1\15\7\12\1\0"+
      "\1\16\1\0\1\6\2\0\7\4\1\17\4\4\1\20"+
      "\5\4\1\21\7\4\1\0\1\6\1\0\1\6\6\0"+
      "\1\2\371\0\1\22\u01a8\0\2\2\326\0\u0100\2";
  
    private static int [] zzUnpackcmap_blocks() {
      int [] result = new int[1280];
      int offset = 0;
      offset = zzUnpackcmap_blocks(ZZ_CMAP_BLOCKS_PACKED_0, offset, result);
      return result;
    }
  
    private static int zzUnpackcmap_blocks(String packed, int offset, int [] result) {
      int i = 0;       /* index in packed string  */
      int j = offset;  /* index in unpacked array */
      int l = packed.length();
      while (i < l) {
        int count = packed.charAt(i++);
        int value = packed.charAt(i++);
        do result[j++] = value; while (--count > 0);
      }
      return j;
    }
  
    /**
     * Translates DFA states to action switch labels.
     */
   private static final int [] ZZ_ACTION = zzUnpackAction();
 
   private static final String ZZ_ACTION_PACKED_0 =
     "\4\0\1\1\1\2\1\3\3\1\1\4\2\5\1\4"+
     "\1\3\2\2\3\0\2\6\1\7\2\0\1\10\1\11";
 
   private static int [] zzUnpackAction() {
     int [] result = new int[27];
     int offset = 0;
     offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
     return result;
   }
 
   private static int zzUnpackAction(String packed, int offset, int [] result) {
     int i = 0;       /* index in packed string  */
     int j = offset;  /* index in unpacked array */
     int l = packed.length();
     while (i < l) {
       int count = packed.charAt(i++);
       int value = packed.charAt(i++);
       do result[j++] = value; while (--count > 0);
     }
     return j;
   }
 
 
   /**
    * Translates a state to a row index in the transition table
    */
   private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
 
   private static final String ZZ_ROWMAP_PACKED_0 =
     "\0\0\0\23\0\46\0\71\0\114\0\137\0\114\0\162"+
     "\0\205\0\230\0\114\0\114\0\253\0\276\0\321\0\114"+
     "\0\344\0\367\0\u010a\0\u011d\0\114\0\u0130\0\114\0\276"+
     "\0\u0143\0\114\0\114";
 
   private static int [] zzUnpackRowMap() {
     int [] result = new int[27];
     int offset = 0;
     offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
     return result;
   }
 
   private static int zzUnpackRowMap(String packed, int offset, int [] result) {
     int i = 0;  /* index in packed string  */
     int j = offset;  /* index in unpacked array */
     int l = packed.length() - 1;
     while (i < l) {
       int high = packed.charAt(i++) << 16;
       result[j++] = high | packed.charAt(i++);
     }
     return j;
   }
 
   /**
    * The transition table of the DFA
    */
   private static final int [] ZZ_TRANS = zzUnpacktrans();
 
   private static final String ZZ_TRANS_PACKED_0 =
     "\2\5\2\0\1\5\1\6\1\7\3\5\2\10\1\11"+
     "\1\10\1\7\1\5\1\12\2\5\1\13\1\14\1\0"+
     "\1\15\2\13\1\7\3\16\4\13\1\17\5\13\1\14"+
     "\1\0\1\15\2\13\1\7\7\13\1\17\4\13\1\7"+
     "\1\5\2\0\17\7\23\0\1\6\1\20\1\6\1\21"+
     "\17\6\11\0\5\22\16\0\4\22\1\23\3\0\2\24"+
     "\15\0\1\24\3\0\2\24\1\0\1\14\22\0\1\25"+
     "\1\0\1\26\2\0\1\27\3\30\4\0\1\27\10\0"+
     "\1\31\3\0\6\31\1\0\3\31\2\0\1\20\32\0"+
     "\5\32\16\0\5\32\1\0\1\32\16\0\1\32\3\0"+
     "\1\32\4\0\1\25\25\0\1\31\3\0\6\31\1\33"+
     "\3\31\1\0";
 
   private static int [] zzUnpacktrans() {
     int [] result = new int[342];
     int offset = 0;
     offset = zzUnpacktrans(ZZ_TRANS_PACKED_0, offset, result);
     return result;
   }
 
   private static int zzUnpacktrans(String packed, int offset, int [] result) {
     int i = 0;       /* index in packed string  */
     int j = offset;  /* index in unpacked array */
     int l = packed.length();
     while (i < l) {
       int count = packed.charAt(i++);
       int value = packed.charAt(i++);
       value--;
       do result[j++] = value; while (--count > 0);
     }
     return j;
   }
 
 
   /** Error code for "Unknown internal scanner error". */
   private static final int ZZ_UNKNOWN_ERROR = 0;
   /** Error code for "could not match input". */
   private static final int ZZ_NO_MATCH = 1;
   /** Error code for "pushback value was too large". */
   private static final int ZZ_PUSHBACK_2BIG = 2;
 
   /**
    * Error messages for {@link #ZZ_UNKNOWN_ERROR}, {@link #ZZ_NO_MATCH}, and
    * {@link #ZZ_PUSHBACK_2BIG} respectively.
    */
   private static final String ZZ_ERROR_MSG[] = {
     "Unknown internal scanner error",
     "Error: could not match input",
     "Error: pushback value was too large"
   };
 
   /**
    * ZZ_ATTRIBUTE[aState] contains the attributes of state {@code aState}
    */
   private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
 
   private static final String ZZ_ATTRIBUTE_PACKED_0 =
     "\4\0\1\11\1\1\1\11\3\1\2\11\3\1\1\11"+
     "\1\1\3\0\1\11\1\1\1\11\2\0\2\11";
 
   private static int [] zzUnpackAttribute() {
     int [] result = new int[27];
     int offset = 0;
     offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
     return result;
   }
 
   private static int zzUnpackAttribute(String packed, int offset, int [] result) {
     int i = 0;       /* index in packed string  */
     int j = offset;  /* index in unpacked array */
     int l = packed.length();
     while (i < l) {
       int count = packed.charAt(i++);
       int value = packed.charAt(i++);
       do result[j++] = value; while (--count > 0);
     }
     return j;
   }
 
   /** Input device. */
   private java.io.Reader zzReader;
 
   /** Current state of the DFA. */
   private int zzState;
 
   /** Current lexical state. */
   private int zzLexicalState = YYINITIAL;
 
   /**
    * This buffer contains the current text to be matched and is the source of the {@link #yytext()}
    * string.
    */
   private char zzBuffer[] = new char[Math.min(ZZ_BUFFERSIZE, zzMaxBufferLen())];
 
   /** Text position at the last accepting state. */
   private int zzMarkedPos;
 
   /** Current text position in the buffer. */
   private int zzCurrentPos;
 
   /** Marks the beginning of the {@link #yytext()} string in the buffer. */
   private int zzStartRead;
 
   /** Marks the last character in the buffer, that has been read from input. */
   private int zzEndRead;
 
   /**
    * Whether the scanner is at the end of file.
    * @see #yyatEOF
    */
   private boolean zzAtEOF;
 
   /**
    * The number of occupied positions in {@link #zzBuffer} beyond {@link #zzEndRead}.
    *
    * <p>When a lead/high surrogate has been read from the input stream into the final
    * {@link #zzBuffer} position, this will have a value of 1; otherwise, it will have a value of 0.
    */
   private int zzFinalHighSurrogate = 0;
 
   /** Number of newlines encountered up to the start of the matched text. */
   @SuppressWarnings("unused")
   private int yyline;
 
   /** Number of characters from the last newline up to the start of the matched text. */
   @SuppressWarnings("unused")
   private int yycolumn;
 
   /** Number of characters up to the start of the matched text. */
   private long yychar;
 
   /** Whether the scanner is currently at the beginning of a line. */
   @SuppressWarnings("unused")
   private boolean zzAtBOL = true;
 
   /** Whether the user-EOF-code has already been executed. */
   @SuppressWarnings("unused")
   private boolean zzEOFDone;
 
   /* user code: */
 
 	private boolean myReturnNewlines;
 	
     /**
      * Default constructor is needed as we will always call the yyreset
      */
     public Er7Lexer() {
         super();
     }
 
     /**
      * Default constructor is needed as we will always call the yyreset
      */
     public Er7Lexer(boolean theReturnNewlines) {
         super();
         myReturnNewlines = theReturnNewlines;
     }
 
 	@Override
     public int yychar() {
         return (int)yychar;
     }
     
 
 
 
   /**
    * Creates a new scanner
    *
    * @param   in  the java.io.Reader to read input from.
    */
   public Er7Lexer(java.io.Reader in) {
     this.zzReader = in;
   }
 
 
   /** Returns the maximum size of the scanner buffer, which limits the size of tokens. */
   private int zzMaxBufferLen() {
     return Integer.MAX_VALUE;
   }
 
   /**  Whether the scanner buffer can grow to accommodate a larger token. */
   private boolean zzCanGrow() {
     return true;
   }
 
   /**
    * Translates raw input code points to DFA table row
    */
   private static int zzCMap(int input) {
     int offset = input & 255;
     return offset == input ? ZZ_CMAP_BLOCKS[offset] : ZZ_CMAP_BLOCKS[ZZ_CMAP_TOP[input >> 8] | offset];
   }
 
   /**
    * Refills the input buffer.
    *
    * @return {@code false} iff there was new input.
    * @exception java.io.IOException  if any I/O-Error occurs
    */
   private boolean zzRefill() throws java.io.IOException {
 
     /* first: make room (if you can) */
     if (zzStartRead > 0) {
       zzEndRead += zzFinalHighSurrogate;
       zzFinalHighSurrogate = 0;
       System.arraycopy(zzBuffer, zzStartRead,
                        zzBuffer, 0,
                        zzEndRead - zzStartRead);
 
       /* translate stored positions */
       zzEndRead -= zzStartRead;
       zzCurrentPos -= zzStartRead;
       zzMarkedPos -= zzStartRead;
       zzStartRead = 0;
     }
 
     /* is the buffer big enough? */
     if (zzCurrentPos >= zzBuffer.length - zzFinalHighSurrogate && zzCanGrow()) {
       /* if not, and it can grow: blow it up */
       char newBuffer[] = new char[Math.min(zzBuffer.length * 2, zzMaxBufferLen())];
       System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
       zzBuffer = newBuffer;
       zzEndRead += zzFinalHighSurrogate;
       zzFinalHighSurrogate = 0;
     }
 
     /* fill the buffer with new input */
     int requested = zzBuffer.length - zzEndRead;
     int numRead = zzReader.read(zzBuffer, zzEndRead, requested);
 
     /* not supposed to occur according to specification of java.io.Reader */
     if (numRead == 0) {
       if (requested == 0) {
         throw new java.io.EOFException("Scan buffer limit reached ["+zzBuffer.length+"]");
       }
       else {
         throw new java.io.IOException(
             "Reader returned 0 characters. See JFlex examples/zero-reader for a workaround.");
       }
     }
     if (numRead > 0) {
       zzEndRead += numRead;
       if (Character.isHighSurrogate(zzBuffer[zzEndRead - 1])) {
         if (numRead == requested) { // We requested too few chars to encode a full Unicode character
           --zzEndRead;
           zzFinalHighSurrogate = 1;
         } else {                    // There is room in the buffer for at least one more char
           int c = zzReader.read();  // Expecting to read a paired low surrogate char
           if (c == -1) {
             return true;
           } else {
             zzBuffer[zzEndRead++] = (char)c;
           }
         }
       }
       /* potentially more input available */
       return false;
     }
 
     /* numRead < 0 ==> end of stream */
     return true;
   }
 
 
   /**
    * Closes the input reader.
    *
    * @throws java.io.IOException if the reader could not be closed.
    */
   public final void yyclose() throws java.io.IOException {
     zzAtEOF = true; // indicate end of file
     zzEndRead = zzStartRead; // invalidate buffer
 
     if (zzReader != null) {
       zzReader.close();
     }
   }
 
 
   /**
    * Resets the scanner to read from a new input stream.
    *
    * <p>Does not close the old reader.
    *
    * <p>All internal variables are reset, the old input stream <b>cannot</b> be reused (internal
    * buffer is discarded and lost). Lexical state is set to {@code ZZ_INITIAL}.
    *
    * <p>Internal scan buffer is resized down to its initial length, if it has grown.
    *
    * @param reader The new input stream.
    */
   public final void yyreset(java.io.Reader reader) {
     zzReader = reader;
     zzEOFDone = false;
     yyResetPosition();
     zzLexicalState = YYINITIAL;
     int initBufferSize = Math.min(ZZ_BUFFERSIZE, zzMaxBufferLen());
     if (zzBuffer.length > initBufferSize) {
       zzBuffer = new char[initBufferSize];
     }
   }
 
   /**
    * Resets the input position.
    */
   private final void yyResetPosition() {
       zzAtBOL  = true;
       zzAtEOF  = false;
       zzCurrentPos = 0;
       zzMarkedPos = 0;
       zzStartRead = 0;
       zzEndRead = 0;
       zzFinalHighSurrogate = 0;
       yyline = 0;
       yycolumn = 0;
       yychar = 0L;
   }
 
 
   /**
    * Returns whether the scanner has reached the end of the reader it reads from.
    *
    * @return whether the scanner has reached EOF.
    */
   public final boolean yyatEOF() {
     return zzAtEOF;
   }
 
 
   /**
    * Returns the current lexical state.
    *
    * @return the current lexical state.
    */
   public final int yystate() {
     return zzLexicalState;
   }
 
 
   /**
    * Enters a new lexical state.
    *
    * @param newState the new lexical state
    */
   public final void yybegin(int newState) {
     zzLexicalState = newState;
   }
 
 
   /**
    * Returns the text matched by the current regular expression.
    *
    * @return the matched text.
    */
   public final String yytext() {
     return new String(zzBuffer, zzStartRead, zzMarkedPos-zzStartRead);
   }
 
 
   /**
    * Returns the character at the given position from the matched text.
    *
    * <p>It is equivalent to {@code yytext().charAt(pos)}, but faster.
    *
    * @param position the position of the character to fetch. A value from 0 to {@code yylength()-1}.
    *
    * @return the character at {@code position}.
    */
   public final char yycharat(int position) {
     return zzBuffer[zzStartRead + position];
   }
 
 
   /**
    * How many characters were matched.
    *
    * @return the length of the matched text region.
    */
   public final int yylength() {
     return zzMarkedPos-zzStartRead;
   }
 
 
   /**
    * Reports an error that occurred while scanning.
    *
    * <p>In a well-formed scanner (no or only correct usage of {@code yypushback(int)} and a
    * match-all fallback rule) this method will only be called with things that
    * "Can't Possibly Happen".
    *
    * <p>If this method is called, something is seriously wrong (e.g. a JFlex bug producing a faulty
    * scanner etc.).
    *
    * <p>Usual syntax/scanner level error handling should be done in error fallback rules.
    *
    * @param errorCode the code of the error message to display.
    */
   private static void zzScanError(int errorCode) {
     String message;
     try {
       message = ZZ_ERROR_MSG[errorCode];
     } catch (ArrayIndexOutOfBoundsException e) {
       message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
     }
 
     throw new Error(message);
   }
 
 
   /**
    * Pushes the specified amount of characters back into the input stream.
    *
    * <p>They will be read again by then next call of the scanning method.
    *
    * @param number the number of characters to be read again. This number must not be greater than
    *     {@link #yylength()}.
    */
   public void yypushback(int number)  {
     if ( number > yylength() )
       zzScanError(ZZ_PUSHBACK_2BIG);
 
     zzMarkedPos -= number;
   }
 
 
 
 
   /**
    * Resumes scanning until the next regular expression is matched, the end of input is encountered
    * or an I/O-Error occurs.
    *
    * @return the next token.
    * @exception java.io.IOException if any I/O-Error occurs.
    */
   public Token yylex() throws java.io.IOException
   {
     int zzInput;
     int zzAction;
 
     // cached fields:
     int zzCurrentPosL;
     int zzMarkedPosL;
     int zzEndReadL = zzEndRead;
     char[] zzBufferL = zzBuffer;
 
     int [] zzTransL = ZZ_TRANS;
     int [] zzRowMapL = ZZ_ROWMAP;
     int [] zzAttrL = ZZ_ATTRIBUTE;
 
     while (true) {
       zzMarkedPosL = zzMarkedPos;
 
       yychar+= zzMarkedPosL-zzStartRead;
 
       zzAction = -1;
 
       zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
 
       zzState = ZZ_LEXSTATE[zzLexicalState];
 
       // set up zzAction for empty match case:
       int zzAttributes = zzAttrL[zzState];
       if ( (zzAttributes & 1) == 1 ) {
         zzAction = zzState;
       }
 
 
       zzForAction: {
         while (true) {
 
           if (zzCurrentPosL < zzEndReadL) {
             zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
             zzCurrentPosL += Character.charCount(zzInput);
           }
           else if (zzAtEOF) {
             zzInput = YYEOF;
             break zzForAction;
           }
           else {
             // store back cached positions
             zzCurrentPos  = zzCurrentPosL;
             zzMarkedPos   = zzMarkedPosL;
             boolean eof = zzRefill();
             // get translated positions and possibly new buffer
             zzCurrentPosL  = zzCurrentPos;
             zzMarkedPosL   = zzMarkedPos;
             zzBufferL      = zzBuffer;
             zzEndReadL     = zzEndRead;
             if (eof) {
               zzInput = YYEOF;
               break zzForAction;
             }
             else {
               zzInput = Character.codePointAt(zzBufferL, zzCurrentPosL, zzEndReadL);
               zzCurrentPosL += Character.charCount(zzInput);
             }
           }
           int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMap(zzInput) ];
           if (zzNext == -1) break zzForAction;
           zzState = zzNext;
 
           zzAttributes = zzAttrL[zzState];
           if ( (zzAttributes & 1) == 1 ) {
             zzAction = zzState;
             zzMarkedPosL = zzCurrentPosL;
             if ( (zzAttributes & 8) == 8 ) break zzForAction;
           }
 
         }
       }
 
       // store back cached position
       zzMarkedPos = zzMarkedPosL;
 
       if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
         zzAtEOF = true;
               {
                 return null;
               }
       }
       else {
         switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
           case 1:
             { return token(TokenType.OPERATOR);
             }
           // fall through
           case 10: break;
           case 2:
             { return token(TokenType.COMMENT);
             }
           // fall through
           case 11: break;
           case 3:
             { yybegin(AT_START_OF_VALUE); return token(TokenType.TYPE);
             }
           // fall through
           case 12: break;
           case 4:
             { yybegin(WITHIN_VALUE); return token(TokenType.DEFAULT);
             }
           // fall through
           case 13: break;
           case 5:
             { yybegin(YYINITIAL); return token(TokenType.DEFAULT);
             }
           // fall through
           case 14: break;
           case 6:
             { yybegin(YYINITIAL); return token(TokenType.TYPE2);
             }
           // fall through
           case 15: break;
           case 7:
             { yypushback(1); yybegin(AT_DELIM); return token(TokenType.TYPE2);
             }
           // fall through
           case 16: break;
           case 8:
             { return token(TokenType.KEYWORD);
             }
           // fall through
           case 17: break;
           case 9:
             { return token(TokenType.TYPE3);
             }
           // fall through
           case 18: break;
           default:
             zzScanError(ZZ_NO_MATCH);
         }
       }
     }
   }
 
 
 }