Uses of Class
jpicedt.format.input.util.AbstractRegularExpression

Packages that use AbstractRegularExpression

jpicedt.format.input
jpicedt.format.input.eepic	Parser grammar for the eepic format.
jpicedt.format.input.latex	Parser grammar for the LaTeX picture environment format.
jpicedt.format.input.pstricks	Pstricks grammar tree.
jpicedt.format.input.util	This package contains helper classes for building a parser based on the well-known RegExp scheme, yet with a strong object-oriented approach in mind.

Uses of AbstractRegularExpression in jpicedt.format.input

Subclasses of AbstractRegularExpression in jpicedt.format.input

class

DefaultParser Default implementation of the Parser interface.

Uses of AbstractRegularExpression in jpicedt.format.input.eepic

Subclasses of AbstractRegularExpression in jpicedt.format.input.eepic

class	EepicDrawlineCommand Eepic open polygon, possibly dashed : \\drawline[stretch](x1,y1)...
class	EepicLineThicknessExpression \thinlines or \thicklines or (eepic) \Thicklines
class	EepicParser Grammar tree for the epic/eepic parser.
class	EepicPathCommand Eepic "fast" (solid) polygon : \\path(x1,y1)...

Uses of AbstractRegularExpression in jpicedt.format.input.latex

Subclasses of AbstractRegularExpression in jpicedt.format.input.latex

class	BeginPictureExpression LaTeX or eepic : \begin{picture}(w,h) \begin{picture}(w,h)(x,y)
class	EndPictureExpression \end{picture}
class	LaTeXBox Parses LaTeX boxes, i.e. makebox, framebox, frame and dashbox.
class	LaTeXCircle Parses LaTeX circles, i.e.
class	LaTeXInstanciationExpression instanciates a new Element by cloning the given object, when it finds the given tag, then adds it to the current PicGroup ; makes use of the PicAttributeSet associated with the ATTRIBUTES key in LaTeXParser.
class	LaTeXLine Parses LaTeX lines, with or without arrows, i.e.
class	LaTeXOval Parses LaTeX \\oval command.
class	LaTeXParser Grammar rules for the LaTeX's picture environment parser
class	LaTeXPicPointExpression an expression that parses "(x,y)" string (LaTeX-like PicPoint) and gives the corresponding numerical values to the point number "ptNumber" of the current Element using its setCtrlPt(), using the given constraint.
class	LaTeXPutExpression \\put(x,y){argument} Depending on the argument found, instanciates : a PicText : \\makebox, \\framebox, \\dashbox or LR-argument a PicMultiCurve : \\line, \\vector.
class	LineThicknessExpression Legal syntax : \\linethickness{0.4pt} \\linethickness{0.4mm} \\linethickness{0.4cm} \\linethickness{0.4} // default to mm note : 1pt = 1/72.27 inch = 0.3515 mm cf.
class	PicArrowTypeExpression "0/1 0/1" arrow type (we take for granted that this string is followed by a LaTeX-picPoint, as in %Line 0 1 (2.3,4.5)..., possibly with leading whitespaces)
class	PicBezierExpression Parser expression for : %Bezier 0|1 0|1 (x1,y1)(xC,yC)(x2,y2) dash=value Any string %End Bezier where dash is optional.
class	PicColorExpression jPicEdt syntax (ie lines starting with a %) color : filled/blacken/whiten/shade
class	PicDashStatement Handles dash statements in jPicEdt-syntax (ie TeX-like comments) % ... dash= ...
class	PicEllipseExpression PicEllipse : %Ellipse(x0,y0)(width)(height) %Ellipse(x0,y0)(width,height) filled|whiten|blacken|shade arcStart= arcExtent= Any string (multiput...)
class	PicEndExpression Match "%End XXXX"-like expressions at the beginning of a line (or preceeded by whitespaces), after skipping as many lines as necessary.
class	PicGroupExpression PicGroup: %Begin group ...
class	PicLineExpression PicLineExpression : %Line 0 0 (x0,y0)(x1,y1) dash=value %Line 0 1 (x0,y0)(x1,y1) dash=value %Line 1 0 (x0,y0)(x1,y1) dash=value %Line 1 1 (x0,y0)(x1,y1) dash=value (dash is optional) Any string (\multiput, etc…) %End Line
class	PicPolygonExpression PicPolygon : %Polygon (x1,y1)...
class	PicRectangleExpression %Rectangle(x0,y0)(x1,y1) or %Rectangle(x0,y0)(x1,y1) filled|blacken|shade|whiten dash=value Any string %End Rectangle
class	UnitLengthExpression \\unitlength value \\setlength{\\unitlength}{value} where value's permitted syntaxs are : 0.11, 0.11mm, 0.11cm, 0.11pt with possible leading whitespaces before the "unit".

Uses of AbstractRegularExpression in jpicedt.format.input.pstricks

Subclasses of AbstractRegularExpression in jpicedt.format.input.pstricks

class	BeginPsPictureExpression \begin{pspicture}(x0,y0)(x1,y1) -> defines a box with BL=(x0,y0) and TR=(x1,y1) \begin{pspicture}*(x0,y0)(x1,y1) -> clipped \begin{pspicture}[baseline](x0,y0)(x1,y1) -> changes baseline (see pstricks's doc p.41) \begin{pspicture}[](x0,y0)(x1,y1) -> baseline passes across the origine And the same commands with \pspicture (that is, TeX-like).
class	EndPsPictureExpression \end{pspicture} and/or \endpspicture.
class	PsArcExpression Parses \\psarc commands : \\psarc[parameters]{<->}(x0,y0){rad}{angleA}{angleB} ; where at least "arrows" or (x0,y0) args must be included \\psarc*[parameters]{<->}(x0,y0){rad}{angleA}{angleB} ; idid. but filled
class	PsBezierExpression Rules for parsing cubic splines with a PsTricks syntax : \\psbezier[parameters]{arrows}(x0,y0)(x1,y1)(x2,y2)(x3,y3) \\psbezier*[parameters]{arrows}(x0,y0)(x1,y1)(x2,y2)(x3,y3) or PsTricks's object previously defined by help of a \\newpsobject command.
class	PsBox Parses PsTricks boxes, i.e.
class	PsCircleExpression Quick circle : \\pscircle[parameters](x0,y0){rad} \\pscircle*[parameters](x0,y0){rad}
class	PsEllipseExpression Parses \\psellipse commands : \\psellipse[parameters](x0,y0)(hrad,vrad) \\psellipse*[parameters](x0,y0)(hrad,vrad)
class	PsFrameExpression \\psframe[parameters](x0,y0)(x1,y1) \\psframe*[parameters](x0,y0)(x1,y1)
class	PsObjectExpression Handles \\newpsobject{myobj}{ps_object}{par1=val1,...}
class	PsPolygonExpression Parses \\pspolygon, \\psdots and \\psline commands : \\pspolygon[param](2,4)(3,15) // NO ARROW ALLOWED HERE !
class	PsQDiskExpression Quick disk : (streamlines version of \\pscircle*), \\qdisk(x0,y0)(rad)
class	PsQLineExpression Quick line : \\qline(x0,y0)(x1,y1) Uses default parameters values.
class	PsRPutExpression Parses PsTricks's \\rput commands, either: \\rput[refpoint]{rotation}(x,y){stuff} \\rput*[refpoint]{rotation}(x,y){stuff} (line-breaks being allowed b/w each "block"), where : refpoint = B|b|t for vertical and l|r for horizontal (B = baseline), used only for psframebox and rel.
class	PSTAngleParameter Used by PSTParametersExpression to parse statements involving angles, for instance "hatchangle=45" or "shadowangle=90".
class	PSTArrowExpression Parses Pstricks's arrows, as given by the PsTricks's documentation (p.29).
class	PSTBooleanExpression Used by PSTParametersExpression to parse statements involving true/false parameters values, for instance "shadow=true" or "shadow=false" ...
class	PSTColorExpression Used by PSTParametersExpression to parse statements involving colours, for instance "linecolor=green" (predefined colour) or "fillcolor=MyGray" (user-defined colours).
class	PSTDashExpression Parses statements similar to "dash=1pt 3mm" (first opaque, then transparent).
class	PSTDotStyleExpression Parses statements similar to "dotstyle=style" where style is one of PicObjectConstants predefined dot styles.
class	PSTFillStyleExpression Parses statements similar to "fillstyle=style" where style is one of PicObjectConstants predefined fill styles.
class	PSTInstanciationExpression Instanciates a new Element by cloning the given object, when a given tag gets found.
class	PSTLengthParameter Parses statement involving length units (as set by PsTricks's "runit" register), e.g.
class	PSTLineStyleExpression Parses statements similar to "linestyle=style" where style is one of PicObjectConstants predefined line styles.
class	PSTParametersExpression PsTricks graphics parameters, e.g.
class	PSTPicPointExpression an expression that parses "(x,y)" string (PsTricks-like PicPoint) and gives the corresponding numerical values to the point number "ptNumber" of the current Element, possibly using a given EditPointConstraint.
class	PstricksParser Root expression for the Pstricks parser, containing grammar rules for the pstricks format.
class	PsUnitLengthExpression Used by PSTParamExpression to parse statement involving the 4 pstricks length registers, that is "unit=1mm,xunit=1mm,yunit=1mm,runit=1mm" (or pt or cm), where setting "unit" sets "xunit", "yunit" and "runit" simultaneously.
class	StarExpression Handles (usually optional) "*" after \\psframebox,\\pspolygon,... by setting FILL_STYLE to SOLID.
class	UserDefinedColorExpression Parse statement defining user-colours, that is : \\newgray{user-def colour name}{num} (where num is a gray scale specification b/w 0 and 1) \\newrgbcolor{user-def-colour-name}{num1 num2 num3} (where num are numbers b/w 0 and 1) \\newhsbcolor{user-def-colour-name}{num1 num2 num3} (where num are numbers b/w 0 and 1) \\newcmykcolor{user-def-colour-name}{num1 num2 num3 num4} (where num are numbers b/w 0 and 1) Colour names may contain letters and numbers.

Uses of AbstractRegularExpression in jpicedt.format.input.util

Subclasses of AbstractRegularExpression in jpicedt.format.input.util

class	AlternateExpression A regular expression that mimics the "x|y" RegExp syntax.
class	CommentExpression Parse comment strings.
class	EnclosingExpression An expression that can encompass a sub-expression it encloses with markers, e.g. "{" + sub-expression + "}" The interpret() methods work as follows : look up an endMarker matching beginMarker in Context.getRemainingSubstring (that is, skip enclosed blocks with the same markers type) set this endMarker as the new Context's endMarker save enclosed expression as "value", and interpret it restore old Context's endMarker
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	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. "(12.3, 34.5)" or "[12.1;-16]" If a coordinate conversion is necessary, it must be computed in the body of the action() method
class	RegExExpression An expression specified by a java.util.regex.Pattern regular expression.
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. a name followed by an assignment sign followed by a numerical value e.g.
class	WhiteSpaces Multiple white spaces (w/o line-feeds)
class	WhiteSpacesOrEOL Multiple white spaces and/or '\n'
class	WildCharExpression a RegExp that represents a single occurence of a wild-char, i.e.
class	WordExpression A RegExp that parses a word, that is, a string: either composed of letters only, or letters and digits only (see java.lang.Character.isLetter() for details), or terminated by the specified end-delimiter (in which case it may contain chars not restricted to letters)

Methods in jpicedt.format.input.util that return AbstractRegularExpression

AbstractRegularExpression

ParserEvent.getSource()

Methods in jpicedt.format.input.util with parameters of type AbstractRegularExpression

void	SequenceExpression.add(AbstractRegularExpression expr) add the given expression to the sequence
void	AlternateExpression.add(AbstractRegularExpression expr) Add a new child to this AlternateExpression.
void	EnclosingExpression.setChild(AbstractRegularExpression child) Change the Expression that must be parsed inside the delimiters to the given expression (can be null)
void	RepeatExpression.setPattern(AbstractRegularExpression expr) Set the base-pattern to the given expression

Constructors in jpicedt.format.input.util with parameters of type AbstractRegularExpression

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

EnclosingExpression(String openingDelimiter, AbstractRegularExpression child, String closingDelimiter)

EnclosingExpression(String openingDelimiter, AbstractRegularExpression child, String closingDelimiter, boolean noLineFeed)

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

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

REParserException.BeginGroupMismatch(Context c, AbstractRegularExpression expr)

REParserException.BlockMismatch(Context c, AbstractRegularExpression expr)

REParserException.EndGroupMismatch(Context c, AbstractRegularExpression expr)

REParserException.EOF(Context c, AbstractRegularExpression expr)

REParserException.IncompleteSequence(Context c, AbstractRegularExpression expr)

REParserException.NotFoundInFile(Context c, AbstractRegularExpression expr)

REParserException.NumberFormat(Context c, AbstractRegularExpression expr)

REParserException.NumberSign(Context c, AbstractRegularExpression expr)

REParserException.SyntaxError(Context c, AbstractRegularExpression expr)

REParserException(String message, Context context, AbstractRegularExpression expr)
create a new REParserException, raised by the given Expression

RepeatExpression(AbstractRegularExpression expr, int repeat, int mode)

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

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, AbstractRegularExpression expr3, boolean throwIncompleteSequenceException)
constructs a sequence with three sub-expressions

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

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