|
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |
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 |
AlternateExpression.add(AbstractRegularExpression expr)
Add a new child to this AlternateExpression. |
void |
SequenceExpression.add(AbstractRegularExpression expr)
add the given expression to the sequence |
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. |
|
|
|||||||||
PREV NEXT | FRAMES NO FRAMES |