LpexCommonParser (LPEX API Reference)

Overview

Package

Class

Tree

Serialized

Deprecated

Index

Help

LPEX
4.4.0

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.ibm.lpex.core
Class LpexCommonParser

java.lang.Object
  com.ibm.lpex.core.LpexCommonParser

All Implemented Interfaces:: LpexConstants, LpexParser

Direct Known Subclasses:: CobolParser, CppParser, FortranParser, HtmlParser, JavaParser, JclParser, PliParser, PropertiesParser, RexxParser, SqlParser, TestParser1, TestParser2, XmlParser, XslParser

public abstract class LpexCommonParser
extends Object
implements LpexParser, LpexConstants
extends Object
implements LpexParser, LpexConstants

LpexCommonParser is a base, abstract class for document parsers. It adds several services to the LpexParser interface, simplifying document-parser development, and provides methods for a common look-and-feel to the parsers extending it. Certain methods in the basic LpexParser interface are not used by parsers extending LpexCommonParser.

A document parser is associated with one particular view of a document. Different views of the same document may be handled by different parsers. There is up to one instance of this class for each document view.

Constructor

The parser must have a constructor whose parameter is the associated document view, as shown below:

 
 public class MyLpexParser extends LpexCommonParser 
 {
  public MyLpexParser(LpexView lpexView)
  {
   super(lpexView);
   // rest of MyLpexParser constructor...
  }
  // rest of MyLpexParser...
 }

The document view associated with this parser instance can be retrieved with lpexView().

Life cycle

This is the life cycle of an LPEX document parser:

The parser class is loaded in the editor
The parser constructor is invoked
The initialize method is called in an LpexCommonParser-based parser
Parser's total parse method is called for an initial parse of the document view
The parser is called to parse incrementally every time a change to the document is completed
The parser is notified of its upcoming termination
Its class is unloaded.

The process above takes place for each edit session of a document view, whenever there is a parser associated with that document type or a parser is explicitly specified. It also takes place any time the updateProfile command is run in a view, either called explicitly or as a result of other actions (such as a document reload).

This makes it important to handle the parser termination and reinstantiation correctly, especially when there are other resources and tools initiated from, or associated with, the document parser. Document models that are updated solely on the basis of information provided by the parser calls, should be refreshed when a document parser is (re)instantiated.

Total and incremental parse

There are two main callback methods in a document parser:

parseAll() - total parse: parse the entire document. This method is normally called when a new document has been loaded in the editor, whenever the updateProfile command was run and the parser has been reinstantiated, and when a total parse is activated directly (with, for example, the parse all editor command).

parseElement(int element) - incremental parse: parse changes to the document. This method is normally called when a change has been committed in the editor (for example, the text on a document line was edited and then the cursor was moved off that line), and when an incremental parse is activated directly (with, for example, the parse editor command).

The element parameter indicates an element whose committed change triggered the parse, or the element that precedes or follows a deleted block. The parser may have to identify other neighboring elements that will have to be reparsed as one unit, for example an element that is part of a multi-line javadoc comment in a Java source document.

In addition, for performance reasons, a parser should check whether neighboring elements have changed (in the case that the incremental parse was triggered, for example, by a multi-line paste or block operation), and parse them as one unit during the same call, eliminating the overhead of additional parseElement() callbacks. This is accomplished with the parsePending() and elementParsed() methods.

Changes to the document carried out during parsing are not recorded in the parse-pending list of elements.

Styles

The basic tokenization of the document text is done by setting styles. The style of an element determines the way the element is displayed. The parser sets a string of style characters that is usually the same length as the text of the element. The editor draws each character of the element text with the attributes of the style character that is in the corresponding position in the element style string. This provides syntax coloring of the document, and delimits tokens for other purposes, such as word selection.

The styles also break the line of text into separate segments for painting. These discrete segments override the default behaviour of text layout algorithms. For example, bidirectional reordering can happen within a token, but not between two adjacent tokens.

Editor actions

Several default editor actions are modified by parsers that extend LpexCommonParser:

blockMarkWord to select a token
findMatch, match to match language constructs (such as do - end) for document parsers that extend matchToken()
indentText to indent the text on the current line
openLine, splitLine to indent the text and the cursor (current document location) in the new element
newLine to indent the cursor (current document location) in the new element.

Action and its assigned key added by LpexCommonParser-based parsers:

proto (Ctrl+R) to expand templates defined in the parser properties.

Keys already defined (for example, by the active base profile) to an action different from nullAction are not redefined in here.

The proto action expands a prototype word at the current document location using the template defined in the active document parser. The cursor is set to the position of the first '?' encountered in the expansion, if any. The expansion string is obtained through a call to getProperty(), with the prototype word found at the cursor (and delimited by white space or token-delimiter characters), prefixed by "proto.", as the key argument. For example, if the cursor is located on the word "if" in a C/C++ source document, the value of the CppParser property "proto.if" is used for the expansion. Argument substitution(s) required in the expansion string should be carried out by the parser, and the final string should be returned by its implementation of method getProperty(). When the document is empty, the proto action uses the key PROTOKEY_EMPTY, if an expansion value is defined for it, to set up an initial text to serve as the basic structure for the document.

Embedded messages

The API for accessing the contents of the view being parsed, and in general the operation of most document parsers, use element ordinal numbers exclusively. Therefore, special care should be taken when modifying the contents of the document while processing the parseAll() and parseElement() calls. In general, this should be avoided. See Lines and elements.

During parsing, embedded error and informational messages (which use show lines) should only be added and removed with LpexCommonParser's addMessage(), removeMessages(), addDocumentMessage(), and removeDocumentMessages(), methods. Outside parsing, these methods should not be used.

See also Multiple document views for additional considerations when several views are opened on a document.

Parser properties

Parser properties are parser-specific settings. Certain common parser properties are used by LpexCommonParser and are, therefore, in effect in all the parsers that extend it:

autoIndent - to enable/disable auto-indenting (if not specified, assumed to be "on")
errorMessages - to turn on/off the embedding of parser error messages (via the addMessage() methods) (if not specified, assumed to be "on")
maintainBidiMarks - convenience, document-scoped property to indicate whether inter-token bidi marks should be inserted by the primary parser during incremental parsing of documents with a bidirectional (Arabic or Hebrew) source encoding; use the document. prefix to set and query this property (if not specified, assumed to be "off"); see also Bidi support
parseAfterEveryKey - if specified, it overrides the parseAfterEveryKey parameter setting in effect in the editor; may be set to "on", "off", or "bidi" (parse after every key when running in a bidi environment); see also Bidi support
proto.keyword - keyword expansion template for the proto action
style.styleCharacter and styles.backgroundColor - used, for instance, by preference pages that customize parser styles; see setStyle()
styleName.styleCharacter - used, for instance, by preference pages that customize parser styles; see getStyleName()
tokenHighlight - to turn token highlighting (syntax coloring) on/off (if not specified, assumed to be "on"); see also setStyle()
wordBreaks - to define word-break criteria for the word navigation actions nextWord, prevWord, blockMarkNextWord, and blockMarkPrevWord; one or more of the following parameters can be used:
- caseChange - break on lower to upper case changes
- defineChars - define the characters that are considered part of a word. The default definition of a word in LPEX for the purpose of the word navigation editor actions is any segment of characters delimited by whitespace; this parameter changes this definition to what the method isWordCharacter() defines, by default all letters and digits (this method may be further extended or overridden by the parser)
- fieldStart - break at the start of an editing field
- nonWordChars - break on non-word characters (also stops on start and end of lines)
- styleChange - break on a change in style (new token).

The default scope of a parser property is the document parser for which it is defined. Any instance of the parser in any document view will use the same property value, unless overridden by a document- or view-scoped setting. Document-scoped parser properties are prefixed with "document.". View-scoped parser properties are prefixed with "view.". For example, the value of the autoIndent setting used by a specific instance of a document parser may be changed by the view.autoIndent parser property.

Parser properties may be defined at several levels.

The installation settings of parser properties are defined in the parser profile. An example is the file Profile.properties, a C/C++ document parser profile.
Default settings, which override the installation settings, are stored in the editor defaults profile (see the defaultProfile editor parameter).
View settings, which override the default settings for a particular parser instance, are stored in the associated document view.

Most parser properties are also accessible through the parserProperty editor parameter. A parser may listen to changes effected to any of its properties by extending propertySet().

See getProperty() and setProperty() for additional information on parser properties.

Multiple document views

As there may be several views opened on the same document, each view being associated with a different parser instance, but most commonly document parsers of the same type, several features should be carefully considered. Remember, the incremental parse callback will be invoked in all the parsers associated with the document, on every completed change to the text of the document.

If the parser performs such functions as triggering an external document syntax-checking utility, you only have to invoke this utility from one of the parsers associated with the views of one document. See also addDocumentMessage(), removeDocumentMessages(), and copyDocumentMessages().
If the parser reformats the document text (for example, supports automatic uppercasing, automatic indentation, or code reformatting), you should reformat the text from only one of the parsers associated with the document.
Depending on the features your editor application provides, contributions to the pop-up menu, and in general the functions made available, may be different in each view instance of the parser.

Related method: isPrimaryParser(). Related editor parameters: documentId, documentViews, multipleViews, viewId.

Language-sensitive help

LpexCommonParser provides a few basic services for the implementation of language-sensitive help (LSH) on any platform:

getLshToken() determines the current token in the edit area. This is done based on the text at the current document position (cursor), or any specific text selection in effect in the view. The token returned may then be used as the key into a table that maps language keywords to particular help panels.
Document parsers may extend getLshToken() to further refine the generation of the key which will be used to access the help-mapping table. This is needed in those cases in which the cursor is located in particular contexts inside the document, such as comment lines, identifiers, embedded error messages (displayed as show lines), and so on, where the token returned by method getLshToken() is not a recognized (reserved) keyword in the language. The COBOL parsers, for example, extend getLshToken().
Document parsers which implement other LSH schemes (such as particular help directly addressing the specific document source code, for example help based on information available in a code store which was created by parsing an entire project) may use getToken() instead, to simply retrieve the current token or selection.

Mixed content documents

Source files opened in the editor may contain several distinct content types. Examples of mixed content documents, in which there is a main language and one or more secondary languages or scripts include: C/C++ source code with embedded SQL and/or CICS statements, Java source code with embedded SQL, and HTML code with JavaScript sections.

In these cases, the parser for the main language (normally installed through the file name extension - parser association mechanism) invokes the appropriate subparsers (secondary parsers) for those sections of the document that contain other types of content. Several document parsers shipped with LPEX are designed in this manner: C/C++, COBOL, PL/I, and Java document parsers support embedded SQL and CICS statements. The full set of context-sensitive services which is ordinarily provided by a document parser written specifically for a language as the main, or unique, document language becomes thus available for all the different sections of the document.

Being done under the full control of the main document parser, a well-integrated functionality and look is achieved. The document parser defines and registers with the editor the styles and the element classes for use by all the subparsers in the document context supported. A subparser can query the main document language to determine, for example, the end-of-construct it must detect, the type of comments which should be accepted, etc. For example, the SQL subparser may detect the end of embedded SQL by a semicolon ';' in a C/C++ and PL/I document, and an "END-EXEC" token in a COBOL document. Comments acceptable in the main language, preprocessed (removed) before the source is passed on to the secondary language compilers or interpreters, must also be accepted by the secondary document parsers.

LpexCommonParser defines a generic set of return codes which may be used for communication between the main parser and the subparsers: LEXER_RC_OK, LEXER_RC_EOF, LEXER_RC_END, and LEXER_RC_MORE. Each parser may contribute its own items to the pop-up menu. Method getLanguage(LpexDocumentLocation) is provided to query the document content type at a specific location.

Bidi support

For general information on multicultural support in LPEX, see LpexNls. Some considerations for bidirectional language support in document parsers are detailed in here.

Using effective text and style. When the document format is smart-logical, you may find it convenient to strip the bidi marks from the element text before parsing it. You must then adjust the effective style string set by the parse operation for any bidi marks in the text before setting it in the editor. See LpexNls.stripBidiMarks(java.lang.String) and LpexNls.setStyleBidiMarks(int, java.lang.String).
Parsing after every key. By default, in order to create the least amount of 'noise' (for example, error messages caused by incomplete constructs), incremental parsing is only activated once the cursor leaves the current line (that is, the changes to the text are considered committed). In certain bidi editing scenarios, where the correct visual layout of the text relies on the tokenization of the text, this does not provide an ideal text editing experience for the user. Not only does the line appear incorrect until the parser is triggered, making it difficult to type the desired text, but once that happens (for example, when the user moves the cursor off the line or presses Enter) the text in the line may change around suddenly.

LPEX provides the option to have the parser activated after every key. Ideally, a parser should operate in this mode when running in an active bidi environment. A solution editor may set the parseAfterEveryKey property for those document parsers which are safe to run in this manner and do not already have this setting as the install value in their profile (parseAfterEveryKey set to either "on" or "bidi"). Consideration must be given to other functions activated by the parser (such as syntax checking, source reformatting, or an associated outline view) which are generally time consuming and may generate error messages, so that they are activated less often than after each and every keystroke. Also, parsers may have to be modified to be more lenient in announcing errors for incomplete constructs, or provide additional keying support. For example, in languages such as C/C++ the parser may automatically enter the second double-quote " when the user types a double-quote ", to prevent announcing an error for the unterminated string.
Maintaining bidi marks. The maintainBidiMarks parser property is supported by most LPEX-shipped document parsers. Its default value is "off". It should only be activated by the solution editor in conjunction with similar support in its workstation - remote communications layer, and for local files with a smart-logical format. See LpexNls.setTextStyleBidiMarks(int, java.lang.String).

Example

An example of developing a simple document parser is available in the samples package. See TestParser1 and TestParser2.

Field Summary
`static String`	`ATTRIBUTES_COMMENT` Style attributes for comment/remark tokens.
`static String`	`ATTRIBUTES_COMMENT_KEYWORD` Style attributes for special keywords inside comments.
`static String`	`ATTRIBUTES_COMMENT1` Additional style attributes for comment/remark tokens.
`String`	`ATTRIBUTES_DEFAULT` Common default style attributes.
`static String`	`ATTRIBUTES_DIRECTIVE` Style attributes for compiler directives.
`static String`	`ATTRIBUTES_ERROR` Style attributes for errors (white background red squiggle underline, like other eclipse editors).
`static String`	`ATTRIBUTES_ERROR1` A less intrusive style attributes for errors (red squiggle).
`static String`	`ATTRIBUTES_KEYWORD` Style attributes for language keywords.
`static String`	`ATTRIBUTES_KEYWORD1` Additional style attributes for language keywords.
`static String`	`ATTRIBUTES_LIBRARY` Style attributes for library-related tokens.
`static String`	`ATTRIBUTES_NONSOURCE` Style attributes for text which does not constitute part of the source proper.
`static String`	`ATTRIBUTES_NUMERAL` Style attributes for numerals.
`static String`	`ATTRIBUTES_STRING` Style attributes for quoted strings.
`static String`	`ATTRIBUTES_STRING1` Additional style attributes for quoted strings.
`static String`	`BACKGROUND_COLOR` Common background color.
`static String`	`CLASS_MESSAGE` Common element class reserved for error messages.
`static String`	`LANGUAGE_CCPP` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_CICS` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_CL` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_COBOL` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_COBOL400` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_COBOLILE` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_DDS` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_DLI` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_FORTRAN` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_HLASM` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_HTML` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_JAVA` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_JCL` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_LISP` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_PERL` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_PLI` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_REXX` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_RPG` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_RPGLEFIXED` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_RPGLEFREE` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_SABRETALK` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_SQL` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_XMI` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_XML` Predefined string for the language or document type supported by a parser.
`static String`	`LANGUAGE_XSL` Predefined string for the language or document type supported by a parser.
`static int`	`LEXER_RC_END` Return code from a subparser's token processing indicating the end of its job.
`static int`	`LEXER_RC_EOF` EOF (end-of-file) flag in the return code from a subparser's token processing.
`static int`	`LEXER_RC_MORE` More-input flag in the return code from a subparser's token processing.
`static int`	`LEXER_RC_OK` Successful return code from a subparser's token processing.
`static int`	`POPUP_END` Indication for parser items at the end of the popup.
`static int`	`POPUP_FILTERVIEW` Indication for parser items in the "Filter view" submenu of the popup.
`static int`	`POPUP_SOURCE` Indication for parser items in the "Source" submenu of the popup.
`static int`	`POPUP_TOP` Indication for parser items at the top of the popup.
`static String`	`PROTOKEY_EMPTY` Key for action proto in an empty document.
`static char`	`STYLE_MESSAGE` Common style reserved for parser messages.
`static String`	`STYLE_NAME` Prefix for the styleName.styleCharacter parser properties.
`protected LpexView`	`view` The view with which this document parser is associated.

Fields inherited from interface com.ibm.lpex.core.LpexConstants
HELP_COMMAND_MAP, LPEX_VERSION, MSG_POPUP_COMMENT, MSG_POPUP_ERRORS, MSG_POPUP_EXCLUDESELECTION, MSG_POPUP_FILTERVIEWMENU, MSG_POPUP_INSERTMENU, MSG_POPUP_SELECTEDMENU, MSG_POPUP_SHOWALL, MSG_POPUP_SOURCEMENU, MSG_POPUP_TASKS, MSG_POPUP_UNCOMMENT, PARSE_PENDING_CHANGE_MASK, PARSE_PENDING_INSERT_MASK, PARSE_PENDING_NEXT_DELETED_MASK, PARSE_PENDING_NEXT_SHOW_DELETED_MASK, PARSE_PENDING_PREV_DELETED_MASK, PARSE_PENDING_PREV_SHOW_DELETED_MASK, PARSE_PENDING_UNDO_MASK, PLATFORM_AWT, PLATFORM_SWT, PLATFORM_SWT_KEY, SHOW_ALL, SHOW_DOCUMENT, SHOW_NONE, SHOW_VIEW, STATUS_FIELDS_NOINSERT, STATUS_FIELDS_TRUNCATE, STATUS_FILE_ERRORREADING, STATUS_FILE_INCORRECTENCODING, STATUS_FILE_NOTFOUND, STATUS_FINDTEXT_INVALIDPATTERN, STATUS_FINDTEXT_NOTFOUND, STATUS_FINDTEXT_ONLYOCCURRENCE, STATUS_FINDTEXT_READONLY, STATUS_FINDTEXT_WRAPPED, STATUS_LOCATE_NOSEQUENCETEXT, STATUS_LOCATE_NOTFOUND, STATUS_LOCATE_WRAPPED, STATUS_SAVE_CANCELLED, STATUS_SAVE_FAILED, STATUS_TEXTLIMIT_ENFORCED, STATUS_TEXTLIMIT_OVERFLOW, STATUS_UNDO_NOTHINGUNDONE

Fields inherited from interface com.ibm.lpex.core.LpexConstants

HELP_COMMAND_MAP, LPEX_VERSION, MSG_POPUP_COMMENT, MSG_POPUP_ERRORS, MSG_POPUP_EXCLUDESELECTION, MSG_POPUP_FILTERVIEWMENU, MSG_POPUP_INSERTMENU, MSG_POPUP_SELECTEDMENU, MSG_POPUP_SHOWALL, MSG_POPUP_SOURCEMENU, MSG_POPUP_TASKS, MSG_POPUP_UNCOMMENT, PARSE_PENDING_CHANGE_MASK, PARSE_PENDING_INSERT_MASK, PARSE_PENDING_NEXT_DELETED_MASK, PARSE_PENDING_NEXT_SHOW_DELETED_MASK, PARSE_PENDING_PREV_DELETED_MASK, PARSE_PENDING_PREV_SHOW_DELETED_MASK, PARSE_PENDING_UNDO_MASK, PLATFORM_AWT, PLATFORM_SWT, PLATFORM_SWT_KEY, SHOW_ALL, SHOW_DOCUMENT, SHOW_NONE, SHOW_VIEW, STATUS_FIELDS_NOINSERT, STATUS_FIELDS_TRUNCATE, STATUS_FILE_ERRORREADING, STATUS_FILE_INCORRECTENCODING, STATUS_FILE_NOTFOUND, STATUS_FINDTEXT_INVALIDPATTERN, STATUS_FINDTEXT_NOTFOUND, STATUS_FINDTEXT_ONLYOCCURRENCE, STATUS_FINDTEXT_READONLY, STATUS_FINDTEXT_WRAPPED, STATUS_LOCATE_NOSEQUENCETEXT, STATUS_LOCATE_NOTFOUND, STATUS_LOCATE_WRAPPED, STATUS_SAVE_CANCELLED, STATUS_SAVE_FAILED, STATUS_TEXTLIMIT_ENFORCED, STATUS_TEXTLIMIT_OVERFLOW, STATUS_UNDO_NOTHINGUNDONE

Constructor Summary
`protected`	`LpexCommonParser(LpexView lpexView)` LpexCommonParser constructor.

Method Summary
`protected void`	`addDocumentMessage(int element, String text, String messageClass, char messageStyle)` Displays an embedded error or informational message for an element in all the views of the document.
`protected void`	`addMessage(int element, String text)` Displays an embedded parser error or informational message for an element.
`protected void`	`addMessage(int element, String text, long messageClass)` Displays an embedded parser error or informational message for an element.
`protected void`	`addMessage(int element, String text, long messageClass, char messageStyle)` Displays an embedded parser error or informational message for an element.
`protected void`	`blockMarkWord()` Implements the redefined editor action blockMarkWord.
`static boolean`	`copyDocumentMessages(LpexView targetView, int sourceViewId, String messageClass)` Convenience method to copy the document messages from an existing view.
`int`	`cursorIndent(int element)` Returns the indent display column of the cursor in the element.
`protected boolean`	`defineFilterAction(String actionName, String includedClasses)` Convenience method to define an action for the "Filter view" menu.
`protected boolean`	`defineFilterAction(String actionName, String includedClasses, String excludedClasses)` Convenience method to define an action for the "Filter view" menu.
`protected void`	`expandProtoKeyword(int s, int e, String p)` Carries out the keyword expansion for the proto action.
`String`	`getCommentStyleCharacters()` Returns the style character(s) used by this parser for comments.
`ArrayList<String>`	`getInstallStyleAttributes()` Returns the install attributes for the style characters defined by this document parser.
`String`	`getLanguage()` Returns a string identifying the language or document type supported by this document parser.
`String`	`getLanguage(LpexDocumentLocation loc)` Returns a string identifying the language segment at the specified location.
`String`	`getLshToken()` Returns the current token for language-sensitive help (LSH).
`protected String`	`getPopupItems(int popupLocation)` Returns this parser's items for the pop-up (context) menu.
`ResourceBundle`	`getProfile()` Returns this document parser's profile.
`String`	`getProperty(String key)` Returns a parser property.
`String`	`getStyleName(char styleCharacter)` Returns the locale-sensitive description of a style defined by this document parser.
`String`	`getStyles()` Returns the style characters defined by this document parser.
`String`	`getTextIndent(int element)` Returns the desired indent string for the text in the specified element.
`String`	`getToken(LpexDocumentLocation loc)` Returns the language token at the specified document location.
`LpexDocumentLocation`	`getTokenLocation(LpexDocumentLocation loc)` Returns the start of the language token at the specified document location.
`int`	`indentText(int element)` Positions the text of an element to the correct indent value.
`int`	`indentText(int element, int desiredIndent)` Positions the text of an element to the specified indent value, given as the column position of the text indented by leading blanks.
`int`	`indentText(int element, String desiredIndent)` Positions the text of an element to the specified indentation.
`protected void`	`initParser()` This parser is being initialized.
`boolean`	`isDebuggable(int line)` Query whether the specified document line is debuggable.
`boolean`	`isPrimaryParser()` Convenience method to determine whether this is considered the primary parser for the document.
`boolean`	`isTokenDelimiter(char c)` Returns whether the specified character is a token delimiter.
`boolean`	`isWordCharacter(int element, int position)` Returns whether the character at the given position in the given element is to be considered part of a word.
`void`	`lineComment(String text, boolean comment)` Generic utility method to comment / uncomment lines.
`LpexView`	`lpexView()` Returns the document view with which this parser is associated.
`protected LpexDocumentLocation`	`matchToken(LpexDocumentLocation loc)` Matches the token found at the specified document location.
`protected void`	`newLine()` Implements the redefined editor action newLine.
`protected void`	`openLine()` Implements the redefined editor action openLine.
`void`	`parse(int element)` N/A - Method in the LpexParser interface; a document parser extending LpexCommonParser only implements `parseElement(int)`.
`abstract void`	`parseAll()` Total parse.
`abstract void`	`parseElement(int element)` Incremental parse.
`protected void`	`propertySet(String key)` The named parser property was set in the scope of this document parser instance.
`protected void`	`removeDocumentMessages(int fromElement, int toElement, String messageClass)` Removes from all the views of the document the embedded messages of the specified element class(es) for the given range of text elements.
`protected void`	`removeMessages(int fromElement, int toElement)` Removes this parser's default messages for a given range of elements.
`protected void`	`removeMessages(int fromElement, int toElement, long messageClass)` Removes this parser's embedded messages of the specified element class(es), for the given range of text elements.
`void`	`resetParser()` N/A - Method in the LpexParser interface; a document parser extending LpexCommonParser only implements, if needed, `terminateParser()`.
`void`	`setProperty(String key, String value)` Sets, updates, or restores a parser property.
`void`	`setStyle(String styles, String installAttributes)` Defines the styles used by the parser for a token or set of tokens.
`protected void`	`splitLine()` Implements the redefined editor action splitLine.
`String`	`styleString(char style, int len)` Utility method to return a style string for a `len`-long token.
`protected void`	`terminateParser()` This parser is being terminated and disposed.
`protected LpexDocumentLocation`	`tokenBegin(LpexDocumentLocation loc)` Returns the start of a token at the specified document location.
`protected LpexDocumentLocation`	`tokenEnd(LpexDocumentLocation loc)` Returns the end of a token at the specified document location.
`void`	`totalParse()` N/A - Method in the LpexParser interface; a document parser extending LpexCommonParser only implements `parseAll()`.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

view

protected LpexView view

The view with which this document parser is associated.

See Also:: lpexView()

CLASS_MESSAGE

public static final String CLASS_MESSAGE

Common element class reserved for error messages. Embedded error and informational messages displayed (as show elements) in the edit view will be by default assigned this element class.

It is defined as "Message". The parser should not define an element class with this name.

See Also:: Constant Field Values

STYLE_MESSAGE

public static final char STYLE_MESSAGE

Common style reserved for parser messages. Embedded error and informational messages displayed (as show elements) in the edit view will be by default assigned this style.

Defined as 'M'. The parser should not define this style for tokens.

See Also:: Constant Field Values