Uses of Class jpicedt.graphic.io.parser.AbstractRegularExpression

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> jpicedt >> graphic >> io >> [ parser overview ]

PREV NEXT

Uses of Class
jpicedt.graphic.io.parser.AbstractRegularExpression

Uses of AbstractRegularExpression in jpicedt.graphic.io.parser

Subclasses of AbstractRegularExpression in jpicedt.graphic.io.parser

class AlternateExpression
          A regular expression that mimics the "x|y" RegExp syntax.

class CommentExpression
          Parse comment strings.

class DefaultParser
          Default implementation of the parser interface [pending : create interface !].

class EnclosingExpression
          An expression that can encompass a sub-expression it encloses with markers, e.g.

class GNURegExpression
          An expression specified by a gnu.regexp.RE regular expression.

class InstanciationExpression
          An expression that can instanciate a new Element by cloning the given graphic element when it finds a given litteral tag, then add it to the current PicGroup in the pool.

class LaTeXParser
          LaTeX (including epic/eepic and pstricks macros) parser This class consists essentially of LaTeX grammar rules (subexpression included in the "root" sequence expression) and a method "parse()" which kicks off the parsing process.

class LiteralExpression
          An expression specified by a String to be exactly matched at the current cursor position.

class NotParsableExpression
          Any string (but w/o line-feeds !)

class NumericalExpression
          An expression containing only digits, possibly preceded by whitespaces ; a post-delimiters can be specified, as well as the number's type (int or double) and its sign

class OptionalExpression
          an expression that represents a pattern repeating at most once

class PicPointExpression
          An expression for 2D-Point parsing e.g.

class RepeatExpression
          an expression that represents a pattern repeating a given number of times

class RootExpression
          This is the super-class for head-expressions that contain grammar rule for a given format.

class SequenceExpression
          An expression that represents a sequence of expressions to be matched exactly in the same order they're being added to the sequence.

class StatementExpression
          An expression for "statement"-parsing, i.e.

class TerminalExpression
          This expression works a bit like a "CR-greedy" expression : it scans each line until it can successfully parse the reg-exp given in the constructor, POSSIBLY preceded by wild-chars (as given in the construror).

class WhiteSpaces
          Multiple white spaces (w/o line-feeds)

class WhiteSpacesOrEOL
          multiple white spaces and/or '\n'

class WildCharExpression
          an Expression that represents a single occurence of a wild-char (ANY_CHAR or one of the predefinite fields in java.lang.Character)

class WordExpression
          A string, - either composed of letters only, or letters and digits (see java.lang.Character.isLetter() for details) only, - or ended by the specified end-delimiter (in which case it may contain other chars than letters)

Fields in jpicedt.graphic.io.parser declared as AbstractRegularExpression

private AbstractRegularExpression TerminalExpression.expr


private AbstractRegularExpression TerminalExpression.wildExpr


private AbstractRegularExpression StatementExpression.exp1


private AbstractRegularExpression StatementExpression.exp2


private AbstractRegularExpression StatementExpression.exp3


private AbstractRegularExpression RepeatExpression.expr


private AbstractRegularExpression PicPointExpression.exp1


private AbstractRegularExpression PicPointExpression.exp2


private AbstractRegularExpression PicPointExpression.exp3


private AbstractRegularExpression PicPointExpression.exp4


private AbstractRegularExpression ParserException.expr
          the expression that raised this exception

private AbstractRegularExpression ParserEvent.source


private AbstractRegularExpression OptionalExpression.expr


private AbstractRegularExpression EnclosingExpression.child

Methods in jpicedt.graphic.io.parser that return AbstractRegularExpression

AbstractRegularExpression ParserEvent.getSource()

Methods in jpicedt.graphic.io.parser with parameters of type AbstractRegularExpression

void SequenceExpression.add(AbstractRegularExpression expr)
          add the given expression to the sequence

void RepeatExpression.setPattern(AbstractRegularExpression expr)
          set the base-pattern to the given expression

void EnclosingExpression.setChild(AbstractRegularExpression child)
          Change the child of this expression to the given expression

void AlternateExpression.add(AbstractRegularExpression expr)
          Add a new child to this AlternateExpression.

Constructors in jpicedt.graphic.io.parser with parameters of type AbstractRegularExpression

TerminalExpression(AbstractRegularExpression expr)
          Calls TerminalExpression(expr, WHITESPACES) => "expr" can only be preceded by whitespaces

TerminalExpression(AbstractRegularExpression expr, int type)


SequenceExpression(AbstractRegularExpression expr)
          constructs a sequence with the given expression as the first sub-expression and which doesn't throw IncompleteSequenceException.

SequenceExpression(AbstractRegularExpression expr, boolean throwIncompleteSequenceException)
          constructs a sequence with the given expression as the first sub-expression.

SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2)
          constructs a sequence with the given expression as the first and second sub-expression and which doesn't throw Exception

SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, boolean throwIncompleteSequenceException)
          constructs a sequence with the given expression as the first and second sub-expression

SequenceExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, AbstractRegularExpression expr3, boolean throwIncompleteSequenceException)
          constructs a sequence with three sub-expressions

RepeatExpression(AbstractRegularExpression expr, int repeat, int mode)


ParserException(java.lang.String errorCode, Context context, AbstractRegularExpression expr)
          create a new ParserException, raised by the given Expression

ParserException.IncompleteSequence(Context c, AbstractRegularExpression expr)


ParserException.NumberFormat(Context c, AbstractRegularExpression expr)


ParserException.NumberSign(Context c, AbstractRegularExpression expr)


ParserException.EndGroupMismatch(Context c, AbstractRegularExpression expr)


ParserException.BeginGroupMismatch(Context c, AbstractRegularExpression expr)


ParserException.BlockMismatch(Context c, AbstractRegularExpression expr)


ParserException.NotFoundInFile(Context c, AbstractRegularExpression expr)


ParserException.SyntaxError(Context c, AbstractRegularExpression expr)


ParserException.EOF(Context c, AbstractRegularExpression expr)


ParserEvent(AbstractRegularExpression source, Context context, boolean parsingSuccessful, java.lang.Object value)


OptionalExpression(AbstractRegularExpression expr)
          the expression to be matched (yet optionally)

EnclosingExpression(java.lang.String openingDelimiter, AbstractRegularExpression child, java.lang.String closingDelimiter, boolean noLineFeed)


EnclosingExpression(java.lang.String openingDelimiter, AbstractRegularExpression child, java.lang.String closingDelimiter)


AlternateExpression(AbstractRegularExpression expr)
          Creates a new AlternateExpression with the given expr as first element

AlternateExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2)
          Creates a new AlternateExpression with the given expr as first and second element

AlternateExpression(AbstractRegularExpression expr1, AbstractRegularExpression expr2, AbstractRegularExpression expr3)
          Creates a new AlternateExpression with the given expr as first, second and third element