Class RegexString

A string literal that is used as a regular expression.

Import path


                                import semmle.code.java.regex.regex

Direct supertypes

StringLiteral

Indirect supertypes

Known direct subtypes

Regex

Predicates

alternation	Holds if the text in the range start,end is an alternation
alternationOption	Holds if the text in the range start,end is an alternation and the text in part_start, part_end is one of the options in that alternation.
backreference	Holds if the text in the range start,end is a back reference
charRange	Holds if the character set starting at `charset_start` contains a character range with lower bound found between `start` and `lower_end` and upper bound found between `upper_start` and `end`.
charSet	Holds if there is a top-level character class beginning at `start` (inclusive) and ending at `end` (exclusive)
charSetChild	Holds if the character set starting at `charset_start` contains either a character or a range found between `start` and `end`.
charSetEnd	Holds if a top-level character set ends at `pos`.
charSetStart	Hold if a top-level character set starts between `start` and `end`.
controlEscape	Holds if there is a control sequence, `\cx`, between `start` and `end`. `x` may be any ascii character including special characters.
emptyGroup	Holds if an empty group is found between `start` and `end`.
escapedCharacter	Holds if an escaped character is found between `start` and `end`. Escaped characters include hex values, octal values and named escapes, but excludes backreferences.
escapingChar	Holds if the character at `pos` is a "" that is actually escaping what comes after.
failedToParse	Holds if the regex failed to parse.
getBackrefName	Gets the name, if it has one, of the back reference in start,end
getBackrefNumber	Gets the number of the back reference in start,end
getChar	Gets the `i`th character of this regex.
getGroupName	Gets the name, if it has one, of the group in start,end
getGroupNumber	Gets the number of the group in start,end
getModeFromPrefix	Gets the mode of this regular expression string if it is defined by a prefix.
getSourceChar	Gets the `i`th character of this literal as it was written in the source code.
getText	Gets the text of this regex
group	Holds if the text in the range start,end is a group
groupContents	Holds if the text in the range start,end is a group with contents in the range in_start,in_end
inCharSet	Holds if `index` is inside a character set.
item	Holds if the range `start`, `end` contains a character, a quantifier, a character set or a group.
multiples	Holds if a repetition quantifier is found between `start` and `end`, with the given lower and upper bounds. If a bound is omitted, the corresponding string is empty.
negativeLookaheadAssertionGroup	Holds if a negative lookahead is found between `start` and `end`
negativeLookbehindAssertionGroup	Holds if a negative lookbehind is found between `start` and `end`
normalCharacter	Holds if a normal character or escape sequence is between `start` and `end`.
positiveLookaheadAssertionGroup	Holds if a positive lookahead is found between `start` and `end`
positiveLookbehindAssertionGroup	Holds if a positive lookbehind is found between `start` and `end`
quantifiedItem	Holds if the text in the range start,end is a quantified item, where item is a character, a character set or a group.
quantifiedPart	Holds if a quantified part is found between `start` and `part_end` and the quantifier is found between `part_end` and `end`.
quote	Holds if a quoted sequence is found between `start` and `end`
quote	Holds if a quoted sequence is found between `start` and `end`, with content found between `inner_start` and `inner_end`.
sequence	Holds if the text in the range start,end is a sequence of 1 or more items, where an item is a character, a character set or a group.
sourceCharacter	Holds if the `i`th character of the string is represented between offsets `start` (inclusive) and `end` (exclusive) in the source code of this literal. This only gives correct results if the literal is written as a normal single-line string literal; without compile-time concatenation involved.
specialCharacter	Holds if a special character `char` is between `start` and `end`.
zeroWidthMatch	Holds if the text in the range start, end is a group and can match the empty string.

Inherited predicates

getAChildExpr	Gets a child of this expression.	from Expr
getAPrimaryQlClass	Gets the name of a primary CodeQL class to which this element belongs.	from StringLiteral
getAnEnclosingStmt	Gets a statement that directly or transitively contains this expression, if any. This is equivalent to `this.getEnclosingStmt().getEnclosingStmt*()`.	from Expr
getBasicBlock	Gets the basic block in which this expression occurs, if any.	from Expr
getCompilationUnit	Gets the compilation unit in which this expression occurs.	from Expr
getControlFlowNode	Gets the `ControlFlowNode` corresponding to this expression.	from Expr
getEnclosingCallable	Gets the callable in which this expression occurs, if any.	from Expr
getEnclosingStmt	Gets the statement containing this expression, if any.	from Expr
getFile	Gets the file associated with this element.	from Top
getHalsteadID	This statement’s Halstead ID (used to compute Halstead metrics).	from Expr
getIndex	Gets the index of this expression as a child of its parent.	from Expr
getKind	Gets the kind of this expression.	from Expr
getKotlinType	Gets the Kotlin type of this expression.	from Expr
getLiteral	Gets a string representation of this literal as it appeared in the source code.	from Literal
getLocation	Gets the source location for this element.	from Top
getNumberOfCommentLines	Gets the number of comment lines that this element ranges over.	from Top
getNumberOfLinesOfCode	Gets the number of lines of code that this element ranges over.	from Top
getParent	Gets the parent of this expression.	from Expr
getPrimaryQlClasses	Gets a comma-separated list of the names of the primary CodeQL classes to which this element belongs.	from Top
getTotalNumberOfLines	Gets the total number of lines that this element ranges over, including lines of code, comment and whitespace-only lines.	from Top
getType	Gets the type of this expression.	from Expr
getUnderlyingExpr	Gets the underlying expression looking through casts and not-nulls, if any. Otherwise just gets this expression.	from Expr
getValue	Gets the string represented by this string literal, that is, the content of the literal without enclosing quotes and with escape sequences translated.	from StringLiteral
hasLocationInfo	Holds if this element is at the specified location. The location spans column `startcolumn` of line `startline` to column `endcolumn` of line `endline` in file `filepath`. For more information, see Locations.	from Top
isCompileTimeConstant	Holds if this literal is a compile-time constant expression (as per JLS v8, section 15.28).	from Literal
isInStaticContext	Holds if this expression occurs in a static context.	from Expr
isNthChildOf	Holds if this expression is the child of the specified parent at the specified (zero-based) position.	from Expr
isParenthesized	Holds if this expression is parenthesized.	from Expr
isTextBlock	Holds if this string literal is a text block (`""" ... """`).	from StringLiteral
toString	Gets a printable representation of this expression.	from Literal