Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| http://www.jpicedt.org
PREV NEXT | FRAMES NO FRAMES

## 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)...(xN,yN)
`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)...(xN,yN)

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.
`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 `setPoint()`, using the given constraint.
`class` | `LaTeXPutExpression` \\put(x,y){argument}
`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 :
`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) % ...
`class` | `PicEllipseExpression` PicEllipse : %Ellipse(x0,y0)(width)(height) %Ellipse(x0,y0)(width,height) filled|whiten|blacken|shade arcStart= arcExtent= Any string (multiput...) %End Ellipse
`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 ... %End group
`class` | `PicLineExpression` PicLine : %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)...(xn,yn) dash=value whiten|shade|blacken closed ...
`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. A REParserException.EndOfPicture is thrown when this expression gets successfully parsed, which give a chance to the receiver to end up the parsing process here.
`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.
`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,...}, for instance \\newpsobject{myline}{psline}{linecolor=green} (param is optional, though in this case, it'd be pretty useless!)
`class` | `PsPolygonExpression` Parses \\pspolygon, \\psdots and \\psline commands : \\pspolygon[param](2,4)(3,15) // NO ARROW ALLOWED HERE ! \\pspolygon*[param](5,1)(5,8)...(xN,yN) \\psline[param]{arrows}(5,1)(5,8)...(xN,yN) \\psline*[param]{arrows}(5,1)(5,8)...(xN,yN) \\psdots[param,dotstyle=style,dotscale=a b,dotangle=angle]{arrows}(5,1)(5,8)...(xN,yN) \\psdots*[param]{arrows}(5,1)(5,8)...(xN,yN) (same as above, '*' being unused) Note : PsPolygon -> close path ; PsLine -> open path ; PsDots -> dots only
`class` | `PsQDiskExpression` Quick disk : (streamlines version of \\pscircle*), \\qdisk(x0,y0)(rad)
`class` | `PsQLineExpression` Quick line : \\qline(x0,y0)(x1,y1)
`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). This is based on the following rules : an opening "{" ; "<", ">", "(",...
`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,...
`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.
`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.
`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.
`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` | `RepeatExpression.setPattern(AbstractRegularExpression expr)` set the base-pattern to the given expression
`void` | `EnclosingExpression.setChild(AbstractRegularExpression child)` Change the Expression that must be parsed inside the delimiters to the given expression (can be null)
`void` | `AlternateExpression.add(AbstractRegularExpression expr)` Add a new child to this AlternateExpression.

Constructors in jpicedt.format.input.util with parameters of type AbstractRegularExpression
`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)`
`REParserException(String message, Context context, AbstractRegularExpression expr)` create a new REParserException, raised by the given Expression
`REParserException.IncompleteSequence(Context c, AbstractRegularExpression expr)`
`REParserException.NumberFormat(Context c, AbstractRegularExpression expr)`
`REParserException.NumberSign(Context c, AbstractRegularExpression expr)`
`REParserException.EndGroupMismatch(Context c, AbstractRegularExpression expr)`
`REParserException.BeginGroupMismatch(Context c, AbstractRegularExpression expr)`
`REParserException.BlockMismatch(Context c, AbstractRegularExpression expr)`
`REParserException.NotFoundInFile(Context c, AbstractRegularExpression expr)`
`REParserException.SyntaxError(Context c, AbstractRegularExpression expr)`
`REParserException.EOF(Context c, AbstractRegularExpression expr)`
`ParserEvent(AbstractRegularExpression source, Context context, boolean parsingSuccessful, Object value)`
`OptionalExpression(AbstractRegularExpression expr)` the expression to be matched (yet optionally)
`EnclosingExpression(String openingDelimiter, AbstractRegularExpression child, String closingDelimiter, boolean noLineFeed)`
`EnclosingExpression(String openingDelimiter, AbstractRegularExpression child, 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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| http://www.jpicedt.org
PREV NEXT | FRAMES NO FRAMES

Submit a bug : syd@jpicedt.org