Colorer.java

/*

 * This file is part of the programmer editor demo

 * Copyright (C) 2001-2005 Stephen Ostermiller

 * http://ostermiller.org/contact.pl?regarding=Syntax+Highlighting

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) 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 General Public License for more details.

 * 

 * See COPYING.TXT for details.

 */

package com.jsql.view.swing.sql.lexer;

import com.jsql.util.LogLevelUtil;

import com.jsql.view.swing.sql.lexer.syntax.Lexer;

import com.jsql.view.swing.sql.lexer.syntax.Token;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import javax.swing.text.AttributeSet;

import java.io.IOException;

import java.lang.ref.WeakReference;

import java.util.*;

/**

 * Run the Syntax Highlighting as a separate thread. Things that need to be

 * colored are messaged to the thread and put in a list.

 */

class Colorer extends Thread {

    /**

     * Log4j logger sent to view.

     */

    /**

     * A simple wrapper representing something that needs to be colored. Placed

     * into an object so that it can be stored in a Vector.

     */

    private static class RecolorEvent {

        private int position;

        private int adjustment;

        public int getPosition() {

        }

        public void setPosition(int position) {

        public int getAdjustment() {

        }

        public void setAdjustment(int adjustment) {

    }

    /**

     * Stores the document we are coloring. We use a WeakReference

     * so that the document is eligible for garbage collection when

     * it is no longer being used. At that point, this thread will

     * shut down itself.

     */

    private final WeakReference<HighlightedDocument> document;

    /**

     * Keep a list of places in the file that it is safe to restart the

     * highlighting. This happens whenever the lexer reports that it has

     * returned to its initial state. Since this list needs to be sorted, and

     * we need to be able to retrieve ranges from it, it is stored in a

     * balanced tree.

     */

    /**

     * As we go through and remove invalid positions we will also be finding

     * new valid positions. Since the position list cannot be deleted from

     * and written to at the same time, we will keep a list of the new

     * positions and simply add it to the list of positions once all the old

     * positions have been removed.

     */

    /**

     * Vector that stores the communication between the two threads.

     */

    /**

     * When accessing the linked list, we need to create a critical section.

     * we will synchronize on this object to ensure that we don't get unsafe

     * thread behavior.

     */

    /**

     * The amount of change that has occurred before the place in the

     * document that we are currently highlighting (lastPosition).

     */

    /**

     * The last position colored

     */

    /**

     * Creates the coloring thread for the given document.

     * 

     * @param document The document to be colored.

     */

    public Colorer(HighlightedDocument document) {

    /**

     * Tell the Syntax Highlighting thread to take another look at this

     * section of the document. It will process this as a FIFO. This method

     * should be done inside a docLock.

     */

    public void color(int position, int adjustment) {

        // figure out if this adjustment effects the current run.

        // if it does, then adjust the place in the document

        // that gets highlighted.

            } else {

            }

        }

                // check whether to coalesce with current last element

                    // both are removals

                    }

                    // both are insertions

                    }

                }

            }

    /**

     * The colorer runs forever and may sleep for long periods of time. It

     * should be interrupted every time there is something for it to do.

     */

    @Override

    public void run() {

            try {

                    // get the next event to process - stalling until the

                    // event becomes available

                        // stop waiting after a second in case document

                        // has been cleared.

                    }

                    }

        }

    private void processEvent(int position, int adjustment) {

        }

        // slurp everything up into local variables in case another

        // thread changes them during coloring process

        }

        SortedSet<DocPosition> workingSet;

        Iterator<DocPosition> workingIt;

        DocPosition dp;

        DocPosition dpEnd;

        // find the starting position. We must start at least one

        // token before the current position

        try {

            // all the good positions before

            // the last of the stuff before

            // if there were no good positions before the requested

            // start,

            // we can always start at the very beginning.

        // if stuff was removed, take any removed positions off the

        // list.

            }

        }

        // adjust the positions of everything after the

        // insertion/removal.

        }

        // now go through and highlight as much as needed

        }

        try {

            Token t;

                // we are playing some games with the lexer for

                // efficiency.

                // we could just create a new lexer each time here,

                // but instead,

                // we will just reset it so that it thinks it is

                // starting at the

                // beginning of the document but reporting a funny

                // start position.

                // Reseting the lexer causes the close() method on

                // the reader

                // to be called but because the close() method has

                // no effect on the

                // DocumentReader, we can do this.

                // After the lexer has been set up, scroll the

                // reader so that it

                // is in the correct spot as well.

                // we will highlight tokens until we reach a good

                // stopping place.

                // the first obvious stopping place is the end of

                // the document.

                // the lexer will return null at the end of the

                // document and wee

                // need to stop there.

                // this is the actual command that colors the stuff.

                // Color stuff with the description of the styles

                // stored in tokenStyles.

                        true

                    );

                    // record the position of the last bit of

                    // text that we colored

                }

                // The other more complicated reason for doing no

                // more highlighting

                // is that all the colors are the same from here on

                // out anyway.

                // We can detect this by seeing if the place that

                // the lexer returned

                // to the initial state last time we highlighted is

                // the same as the

                // place that returned to the initial state this

                // time.

                // As long as that place is after the last changed

                // text, everything

                // from there on is fine already.

                    // look at all the positions from last time that

                    // are less than or

                    // equal to the current position

                            // we have found a state that is the

                            // same

                            // didn't find it, try again.

                        } else {

                            // didn't find it, and there is no more

                            // info from last

                            // time. This means that we will just

                            // continue

                            // until the end of the document.

                        }

                    }

                    // so that we can do this check next time,

                    // record all the

                    // initial states from this time.

                }

            }

            // remove all the old initial positions from the place

            // where

            // we started doing the highlighting right up through

            // the last

            // bit of text we touched.

            }

            // Remove all the positions that are after the end of

            // the file.:

            }

            // and put the new initial positions that we have found

            // on the list.

    /**

     * Stop the thread's method run()

     */

    public void stopThread() {

}

Mutations