Class DjangoRouteRegex

Import path


                                import semmle.python.web.django.General

Direct supertypes

RegexString

Indirect supertypes

Inherited fields

use

from RegExp

Inherited predicates

alternation	Whether the text in the range start,end is an alternation	from RegExp
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.	from RegExp
backreference	Whether the text in the range `start,end` is a back reference	from RegExp
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`.	from RegExp
charSet	Whether there is a character class, between start (inclusive) and end (exclusive)	from RegExp
char_set_child	Holds if the character set starting at `charset_start` contains either a character or a range found between `start` and `end`.	from RegExp
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 `]`.	from RegExp
char_set_start	Helper predicate for `char_set_start(int start, int end)`.	from RegExp
char_set_start	Holds if a character set starts between `start` and `end`.	from RegExp
character	Holds if a simple or escaped character is found between `start` and `end`.	from RegExp
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
emptyGroup	Holds if an empty group is found between `start` and `end`.	from RegExp
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.	from RegExp
escapingChar	Holds if the character at `pos` is a "" that is actually escaping what comes after.	from RegExp
failedToParse	Holds if the `i`th character could not be parsed.	from RegExp
firstItem	Whether the item at [start, end) is one of the first items to be matched.	from RegExp
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
getAMode	Gets a mode (if any) of this regular expression. Can be any of: DEBUG IGNORECASE LOCALE MULTILINE DOTALL UNICODE VERBOSE	from RegExp
getASubExpression	Gets an immediate (non-nested) sub-expression of this expression	from Expr
getAUse	Gets a data-flow node where this string value is used as a regular expression.	from RegExp
getBackrefName	Gets the name, if it has one, of the back reference in start,end	from RegExp
getBackrefNumber	Gets the number of the back reference in start,end	from RegExp
getChar	Gets the `i`th character of this regex	from RegExp
getEnclosingModule	Gets the module in which this expression occurs	from Expr
getGroupName	Gets the name, if it has one, of the group in start,end	from RegExp
getGroupNumber	Gets the number of the group in start,end	from RegExp
getLocation		from Expr
getModeFromPrefix	Gets the mode of this regular expression string if it is defined by a prefix.	from RegExp
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
getText	Gets the text of this regex	from RegExp
group	Whether the text in the range `start,end` is a group	from RegExp
groupContents	Matches the contents of a group.	from RegExp
hasSideEffects	Whether this expression may have a side effect (as determined purely from its syntax)	from Expr
inCharSet	Holds if `index` is inside a character set.	from RegExp
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
item	Holds if the range `start`, `end` contains a character, a quantifier, a character set or a group.	from RegExp
lastItem	Whether the item at [start, end) is one of the last items to be matched.	from RegExp
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.	from RegExp
negativeLookaheadAssertionGroup	Holds if a negative lookahead is found between `start` and `end`	from RegExp
negativeLookbehindAssertionGroup	Holds if a negative lookbehind is found between `start` and `end`	from RegExp
nonEscapedCharAt	Gets the `i`th character of this regex, unless it is part of a character escape sequence.	from RegExp
normalCharacter	Holds if a normal character is found between `start` and `end`.	from RegExp
normalCharacterSequence	Holds if the range [start:end) consists of only ‘normal’ characters.	from RegExp
pointsTo	Holds if this expression might “point-to” to `value` which is from `origin` in the given `context`.	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`.	from Expr
pointsTo	Gets a value that this expression might “point-to”.	from Expr
positiveLookaheadAssertionGroup	Holds if a positive lookahead is found between `start` and `end`	from RegExp
positiveLookbehindAssertionGroup	Holds if a positive lookbehind is found between `start` and `end`	from RegExp
qualifiedItem	Whether the text in the range start,end is a qualified item, where item is a character, a character set or a group.	from RegExp
qualifiedPart	Holds if a qualified part is found between `start` and `part_end` and the qualifier is found between `part_end` and `end`.	from RegExp
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
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. Equivalent to `this.refersTo(value, _)`	from Expr
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.	from RegExp
specialCharacter	Holds if a special character is found between `start` and `end`.	from RegExp
toString	Gets a textual representation of this element.	from Expr
zeroWidthMatch	Whether the text in the range start, end is a group and can match the empty string.	from RegExp

Charpred

DjangoRouteRegex