Expressions | logical expressions modeled and visualized using protocol | Math library

My research of the major syntax and functionality differences from http://www.greenend.org.uk/rjk/tech/regexp.html:

• . in GNU grep does not match null bytes and newlines (but does match newlines when used with --null-data), while Perl, everything except \n is matched.
• [...] in GNU grep defines POSIX bracket expressions, while Perl uses "character" classes. I'm not sure on the details. See http://www.greenend.org.uk/rjk/tech/regexp.html#bracketexpression
• "In basic regular expressions the meta-characters ?, +, {, |, (, and ) lose their special meaning; instead use the backslashed versions \?, \+, \{, \|, \(, and \)." From https://www.gnu.org/software/grep/manual/html_node/Basic-vs-Extended.html. ERE matches PCRE syntax.
• GNU grep \w and \W are the same as [[:alnum:]] and [^[:alnum]], while Perl uses alphanumeric and underscore.
• GNU grep has \< and \> for start and end of word.

Perl supports much more additional functionality:

• "nongreedy {}" with syntax re{...}?
• additional anchors and character types \A, \C, \d, \D, \G, \p, \P, \s, \S, \X. \Z, \z.
• (?#comment)
• shy grouping (?:re), shy grouping + modifiers (?modifiers:re)
• lookahead and negative lookahead (?=re) and (?!re), lookbehind and negative lookbehind (?<=p) and (?
• Atomic groups (?>re)
• Conditional expression (?(cond)re)
• ... and more, see man pcresyntax

The regular expression you copied is for (f)lex, which uses a slightly different syntax for regular expressions. In particular, (f)lex treats " as an ordinary character inside bracketed classes, so [^"\\] is a character class matching anything other than (^) a quotation mark (") or a backslash (\\).

However, in JFlex, the " is a quoting character, whether outside or inside brackets. So the " in the character class is unterminated. Hence the error message.

So you need to backslash-escape it:

You have to make the property overridable, so make it virtual:

try using left join

The version ID value inside your string appears to be surrounded with double quotes. Also, I suggest making the decimal portion optional, in case some versions might not have a minor version component:

The expression keeps the digits because they are not included in the regex search for the split method when creating the String variable.

Try splitting at one or many non-alphanumeric characters (\W+), which may be followed by zero or many digits (\d*).

"\W+\d*"

Adding \d* to the end of your existing regex should also work.

"[^a-z0-9?]\d*"

Tested on regex101 with Java 8.

Please let me know whether this resolved your question.

The below code

It might be preferable to create an expression instead of a character string.

If you want to turn a character string into an expression, you need to parse it:

The hclwrite tool currently has no facility to automatically generate arbitrary expressions. Its helper functions are limited only to generating plain references and literal values. SetAttributeValue is the one for literal values, and so that's why the library correctly escaped the ${ sequence in your string, to ensure that it will be interpreted literally.

If you want to construct a more elaborate expression then you'll need to do so manually by assembling the tokens that form the expression and then calling SetAttributeRaw instead.

In the case of your example, it looks like you'd need to generate the following eight tokens:

• TokenOQuote with the bytes "
• TokenQuotedLit with the bytes hello
• TokenTemplateInterp with the bytes ${
• TokenIdent with the bytes var
• TokenDot with the bytes .
• TokenIdent with the bytes stage
• TokenTemplateSeqEnd with the bytes }
• TokenCQuote with the bytes "

The SetAttributeValue function is automating the simpler case of generating three tokens: TokenOQuote, TokenQuotedLit, TokenCQuote.

You can potentially automate the creation of tokens for the var.stage portion of this expression by using TokensForTraversal, which is what SetAttributeTraversal does internally. However, unless you already have a parsed hcl.Traversal representing var.stage, or unless you need things to be more dynamic than you've shown in practice, I expect that it would take more code to construct that input traversal than to just write out the three tokens literally as I showed above.