riestextpane.java

Pasc+Java 这是一个国外的随机自动机*(RAM)一个学习用的程序

import java.util.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.text.*;
import javax.swing.plaf.*;


/**
 * Diese Klasse stellt ein erweitertes JTextPane dar, um Syntax-Highlighting
 * f黵 Ries bereitzustellen.
 * @version 1.0
 */
public class RiesTextPane extends JTextPane {
    
    /* KLASSENVARIABLEN
     * um die unterschiedlichen Typen in lesbare Beschreibungen umzuwandeln
     */
    private final int REST          = 0;
    private final int SCHLUESSEL    = 1;
    private final int ARRAY         = 2;
    private final int ZAHL          = 3;
    private final int FUNKTION      = 4;
    private final int VERGLEICH     = 5;
    private final int ARITHMETIK    = 6;
    private final int SONDERZEICHEN = 7;
    
    /* KLASSENVARIABLEN
     * f黵 die einzelnen m鰃lichen Typen, um diese unterschiedlich zu
     * formatieren.
     * error_set ist die Formatierung von Fehlern
     */
    private MutableAttributeSet rest_set          = new SimpleAttributeSet();
    private MutableAttributeSet schluessel_set    = new SimpleAttributeSet();
    private MutableAttributeSet array_set         = new SimpleAttributeSet();
    private MutableAttributeSet zahl_set          = new SimpleAttributeSet();
    private MutableAttributeSet funktion_set      = new SimpleAttributeSet();
    private MutableAttributeSet vergleich_set     = new SimpleAttributeSet();
    private MutableAttributeSet arithmetik_set    = new SimpleAttributeSet();
    private MutableAttributeSet sonderzeichen_set = new SimpleAttributeSet();
    private MutableAttributeSet error_set         = new SimpleAttributeSet();
    
    /**
     * Dieser Konstruktor setzt die jeweiligen Formatierungen f黵 das
     * Synatax-Highlighting.
     */
    public RiesTextPane() {
        super();
        StyleConstants.setForeground(schluessel_set, new Color(0,0,255));
        StyleConstants.setBold(schluessel_set, true);       
        StyleConstants.setForeground(zahl_set, new Color(255,0,0));
        StyleConstants.setBold(funktion_set, true);
        StyleConstants.setForeground(vergleich_set, new Color(37,177,0));
        StyleConstants.setBold(vergleich_set, true);
        StyleConstants.setForeground(arithmetik_set, new Color(37,177,0));
        StyleConstants.setBold(arithmetik_set, true);
        StyleConstants.setBold(sonderzeichen_set, true);
        StyleConstants.setBackground(error_set, new Color(255,0,0));
        
        /* Um den automatischen Zeilenumbruch vollst鋘dig zu unterdr點ken,
         * m黶sen die Tabulatoren, die auf feste Marken (wie in OpenOffice,
         * Word, ...) springen, durch Tabulatoren mit festgelegter Textbreite,
         * d.b. eine bestimmtre Anzahl von Leerzeichen ersetzt werden.
         * Der folgende Code wartet auch Tabulatoreingaben, l鰏cht den
         * Tabulator aus dem Document und schreibt daf黵 die Leerzeichen.
         */
        this.getKeymap().addActionForKeyStroke
            (KeyStroke.getKeyStroke('\11'), // \11 ist Tabulator
             new TextAction("tab_pressed") {
                 public void actionPerformed(java.awt.event.ActionEvent e) {
                     JTextPane jtp = (JTextPane)e.getSource(); // JTP holen
                     Document doc = jtp.getDocument(); // Document holen
                     try {
                         /* Hier wird der Tab entfernt und die Leerzeichen
                          * eingef黦t.
                          */
                         doc.remove(jtp.getCaretPosition()-1,1);
                         doc.insertString(jtp.getCaretPosition(), "    ",
                              jtp.getInputAttributes());
                     }
                     catch (BadLocationException ble) {
                     // muss aufgefangen werden...
                     }
                 }
            });
    } // end constructor RiesTextPane()
    
    /**
     * Pr黤t, ob es sich um eine g黮tige Wertvariable handelt.
     * @param token zu pr黤endes Token
     * @return true, falls g黮tige Wertvaraible, ansonsten false.
     */
    private boolean isGueltigeWertvariable(Token token) {
        
        /* wertvariable : Der String des auf G黮tigkeit des Bezeicheners auf
         *                Wertvariableneigenschaft zu 黚erpr黤enden Tokens.
         * zeichen      : Das aktuelle Zeichen aus der Wertvariablen.
         * isGueltig    : Gibt den aktuellen Status der G黮tigkeit an.
         */
        String wertvariable = token.toString();
        char zeichen;
        boolean isGueltig = false;
        
        /* Falls die Variable aus mindestens einem Zeichen besteht, so wird
         * das erste Zeichen auf G黮tigkeit gepr黤t, d.h. falls das erste
         * Zeichen ein Kleinbuchstabe (a-z) ist, so ist isGueltig true.
         */
        if (wertvariable.length() != 0) {
            zeichen = wertvariable.charAt(0); // lese Zeichen
            if (zeichen >= 'a' && zeichen <= 'z') {
                isGueltig = true; // true, falls a-z
            }
        } // end erstes Zeichen
        
        /* Falls weitere Zeichen folgen werden diese auf G黮tigkeit gepr黤t,
         * d.h. g黮tige Zeichen sind entweder Kleinbuchstaben oder Zahlen.
         * Bei ung黮tigen Zeichen wird isGueltig wieder auf false gesetzt.
         */
        for (int i=1; i<wertvariable.length();i++) {
            zeichen = wertvariable.charAt(i); // aktuelles Zeichen lesen
            if (zeichen < '0' // falls kleiner als '0'
                || (zeichen > '9' && zeichen < 'a') // falls zw. '9' und 'a'
                || zeichen > 'z') // falls gr鲞er 'z'
            {
                isGueltig = false; // dann kam ein ung黮tiges Zeichen
            }
        } // end weitere Zeichen
        
        /* Zum Schluss muss 黚erpr黤t werden, ob der Token in Ries ein
         * Schl黶selwort ist. Diese sind keine g黮tigen Wertvariablen.
         */
        if (wertvariable.equals("begin")
            || wertvariable.equals("end")
            || wertvariable.equals("function")
            || wertvariable.equals("if")
            || wertvariable.equals("then")
            || wertvariable.equals("else")
            || wertvariable.equals("for")
            || wertvariable.equals("to")
            || wertvariable.equals("do")
            || wertvariable.equals("while")
            || wertvariable.equals("not")
            || wertvariable.equals("and")
            || wertvariable.equals("or"))
        {
            isGueltig = false;
        }
        
        return isGueltig; // gib G黮tigkeit zur點k
    } // end isGueltigeWertvariable
    
    /**
     * Diese 黚erschriebene Methode verhindert, dass 黚erlange Zeilen
     * automatisch umgebrochen werden und sich so ver鋘derte Zeilennummern
     * ergeben, die nicht mehr mit den Parserfehlermeldungen 黚ereinstimmen.
     * 
     * @return true, falls die Breite des Vater-Objekt gr鲞er gleich der
     *         Breite des user-interface factory Objekts ist, ansonsten false.
     */
    public boolean getScrollableTracksViewportWidth() {
        
        /* Abholen des Vater- und des user-interface-factory-Objekts
         */
        Component parent = this.getParent();
        ComponentUI ui = this.getUI();
        
        /* Falls die Breite des Vater-Objekts gr鲞er oder gleich ist als die
         * des uif-Objekts wird wahr zur點kgegeben.
         * Ansonsten false.
         */
        return (ui.getPreferredSize(this).width <= parent.getSize().width);
    } // end getScrollableTracksViewportWidth()
    
    /* Diese Methode f黦t dem Dokument des RiesTextPanes Text hinzu.
     * 
     * @param text hinzuzuf黦ender Text
     */
    public void append(String text) {
        /* Dokument holen und versuchen den Text hinzuzuf黦en, bei Fehlern
         * ein hoffentlich nie ben鰐igtes Hinweisfenster mit einer Warnung
         * ausgeben.
         */
        DefaultStyledDocument doc = (DefaultStyledDocument)this.getDocument();
        try {
            doc.insertString(doc.getLength(),text, null); // Text hinzuf黦en