http://www.jpicedt.org

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
 


http://www.jpicedt.org

Submit a bug : syd@jpicedt.org