Class RegExp

A StrConst used as a regular expression

Import path

import semmle.python.regexp.internal.ParseRegExp

Direct supertypes

Expr

Indirect supertypes

Known direct subtypes

RegexString

Fields

use

Predicates

alternation	Whether the text in the range start,end is an alternation
alternationOption	Whether 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	Whether 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	Whether there is a character class, between start (inclusive) and end (exclusive)
char_set_child	Holds if the character set starting at `charset_start` contains either a character or a range found between `start` and `end`.
char_set_delimiter	Helper predicate for chars that could be character-set delimiters. Holds if the (non-escaped) char at `pos` in the string, is the (one-based) `index` occurrence of a bracket (`[` or `]`) in the string. Result if `true` is the char is `[`, and `false` if the char is `]`.
char_set_start	Helper predicate for `char_set_start(int start, int end)`.
char_set_start	Holds if a character set starts between `start` and `end`.
character	Holds if a simple or escaped character is found between `start` and `end`.
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 `i`th character could not be parsed.
firstItem	Whether the item at [start, end) is one of the first items to be matched.
getAMode	Gets a mode (if any) of this regular expression. Can be any of: - DEBUG - ASCII - IGNORECASE - LOCALE - MULTILINE - DOTALL - UNICODE - VERBOSE
getAUse	Gets a data-flow node where this string value is used as a regular expression.
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.
getPrefix	Gets the prefix of this regex
getText	Gets the text of this regex
group	Whether the text in the range `start,end` is a group
groupContents	Matches the contents of a group.
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.
lastItem	Whether the item at [start, end) is one of the last items to be matched.
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`
nonEscapedCharAt	Gets the `i`th character of this regex, unless it is part of a character escape sequence.
normalCharacter	Holds if a normal character is found between `start` and `end`.
normalCharacterSequence	Holds if the range [start:end) consists of only ‘normal’ characters.
positiveLookaheadAssertionGroup	Holds if a positive lookahead is found between `start` and `end`
positiveLookbehindAssertionGroup	Holds if a positive lookbehind is found between `start` and `end`
qualifiedItem	Whether the text in the range start,end is a qualified item, where item is a character, a character set or a group.
qualifiedPart	Holds if a qualified part is found between `start` and `part_end` and the qualifier is found between `part_end` and `end`.
sequence	Whether 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.
specialCharacter	Holds if a special character is found between `start` and `end`.
zeroWidthMatch	Whether the text in the range start, end is a group and can match the empty string.

Inherited predicates

contains	Whether this contains `inner` syntactically	from AstNode
containsInScope	Whether this contains `inner` syntactically and `inner` has the same scope as `this`	from AstNode
defines	Whether this expression defines variable `v` If doing dataflow, then consider using SsaVariable.getDefinition() for more precision.	from Expr
getAChildNode	Gets a child node of this node in the AST. This predicate exists to aid exploration of the AST and other experiments. The child-parent relation may not be meaningful. For a more meaningful relation in terms of dependency use Expr.getASubExpression(), Stmt.getASubStatement(), Stmt.getASubExpression() or Scope.getAStmt().	from Expr
getAFlowNode	Gets a flow node corresponding directly to this node. NOTE: For some statements and other purely syntactic elements, there may not be a `ControlFlowNode`	from AstNode
getASubExpression	Gets an immediate (non-nested) sub-expression of this expression	from Expr
getEnclosingModule	Gets the module in which this expression occurs	from Expr
getLocation		from Expr
getParent	Gets a parent of this expression	from Expr_
getParentNode	Gets the parent node of this node in the AST. This predicate exists to aid exploration of the AST and other experiments. The child-parent relation may not be meaningful. For a more meaningful relation in terms of dependency use Expr.getASubExpression(), Stmt.getASubStatement(), Stmt.getASubExpression() or Scope.getAStmt() applied to the parent.	from AstNode
getScope	Gets the scope of this expression	from Expr
hasSideEffects	Whether this expression may have a side effect (as determined purely from its syntax)	from Expr
isArtificial	Whether this syntactic element is artificial, that is it is generated by the compiler and is not present in the source	from AstNode
isConstant	Whether this expression is a constant	from Expr
isParenthesised	Whether the parenthesised property of this expression is true.	from Expr_
isParenthesized	Whether the parenthesized property of this expression is true.	from Expr
pointsTo	Gets a value that this expression might “point-to”.	from Expr
pointsTo	Holds if this expression might “point-to” to `value`.	from Expr
pointsTo	Holds if this expression might “point-to” to `value` which is from `origin`.	from Expr
pointsTo	Holds if this expression might “point-to” to `value` which is from `origin` in the given `context`.	from Expr
refersTo	NOTE: `refersTo` will be deprecated in 2019. Use `pointsTo` instead. Equivalent to `this.refersTo(value, _)`	from Expr
refersTo	NOTE: `refersTo` will be deprecated in 2019. Use `pointsTo` instead. Holds if this expression might “refer-to” to `value` which is from `origin` Unlike `this.refersTo(value, _, origin)`, this predicate includes results where the class cannot be inferred.	from Expr
refersTo	NOTE: `refersTo` will be deprecated in 2019. Use `pointsTo` instead. Gets what this expression might “refer-to”. Performs a combination of localized (intra-procedural) points-to analysis and global module-level analysis. This points-to analysis favours precision over recall. It is highly precise, but may not provide information for a significant number of flow-nodes. If the class is unimportant then use `refersTo(value)` or `refersTo(value, origin)` instead. NOTE: For complex dataflow, involving multiple stages of points-to analysis, it may be more precise to use `ControlFlowNode.refersTo(...)` instead.	from Expr
refersTo	NOTE: `refersTo` will be deprecated in 2019. Use `pointsTo` instead. Gets what this expression might “refer-to” in the given `context`.	from Expr
toString	Gets a textual representation of this element.	from Expr

Charpred

RegExp