Mercurial > hgrepos > Python > libs > pygments-lexer-pseudocode2
comparison pygments_lexer_pseudocode2/algpseudocode.py @ 90:2af4684c8e78
Restrict whitespace before required and optional arguments.
Instead of "\s*" use explicit allowed whitespace chars (" " and "\t").
| author | Franz Glasner <fzglas.hg@dom66.de> |
|---|---|
| date | Sat, 02 May 2026 14:46:28 +0200 |
| parents | 7414eed7b275 |
| children | feb41c8d72d2 |
comparison
equal
deleted
inserted
replaced
| 89:7414eed7b275 | 90:2af4684c8e78 |
|---|---|
| 179 "root": [ | 179 "root": [ |
| 180 (r"\n", Whitespace), | 180 (r"\n", Whitespace), |
| 181 (r"/\*", Comment.Multiline, "multiline-nested-comment"), | 181 (r"/\*", Comment.Multiline, "multiline-nested-comment"), |
| 182 (r"//.*$", Comment.Single), | 182 (r"//.*$", Comment.Single), |
| 183 include("remark"), | 183 include("remark"), |
| 184 (r"(?i)\\(block|state(?:ment)?)\s*(\{)", | 184 (r"(?i)\\(block|state(?:ment)?)[ \t]*(\{)", |
| 185 bygroups(op_symbol(Text), LexBase.op_fixed(Whitespace, " ")), | 185 bygroups(op_symbol(Text), LexBase.op_fixed(Whitespace, " ")), |
| 186 "block-expr"), | 186 "block-expr"), |
| 187 (r"(?i)\\(" | 187 (r"(?i)\\(" |
| 188 r"(?:textstate(?:ment)?)" | 188 r"(?:textstate(?:ment)?)" |
| 189 r"|(?:tstate(?:ment)?)" | 189 r"|(?:tstate(?:ment)?)" |
| 190 r"|(?:textblock)" | 190 r"|(?:textblock)" |
| 191 r"|(?:tblock)" | 191 r"|(?:tblock)" |
| 192 r")\s*(\{)", | 192 r")[ \t]*(\{)", |
| 193 bygroups(op_symbol(Text), LexBase.op_fixed(Whitespace, " ")), | 193 bygroups(op_symbol(Text), LexBase.op_fixed(Whitespace, " ")), |
| 194 "text-statement"), | 194 "text-statement"), |
| 195 (r"\\\n", Text), | 195 (r"\\\n", Text), |
| 196 (r"(?i)\\(" | 196 (r"(?i)\\(" |
| 197 r"(?:prog(?:ram)?)" | 197 r"(?:prog(?:ram)?)" |
| 198 r"|(?:algo(?:rithm)?)" | 198 r"|(?:algo(?:rithm)?)" |
| 199 r"|(?:proc(?:edure)?)" | 199 r"|(?:proc(?:edure)?)" |
| 200 r"|(?:func(?:tion)?|(?:fn))" | 200 r"|(?:func(?:tion)?|(?:fn))" |
| 201 r"|(?:class)" | 201 r"|(?:class)" |
| 202 r")\s*(\{)", | 202 r")[ \t]*(\{)", |
| 203 bygroups(op_translate(Keyword), | 203 bygroups(op_translate(Keyword), |
| 204 LexBase.op_fixed(Whitespace, " ")), | 204 LexBase.op_fixed(Whitespace, " ")), |
| 205 "entity-name"), | 205 "entity-name"), |
| 206 # ENDxxx keywords with optional entity name | 206 # ENDxxx keywords with optional entity name |
| 207 # with name | 207 # with name |
| 209 r"(?:prog(?:ram)?)" | 209 r"(?:prog(?:ram)?)" |
| 210 r"|(?:algo(?:rithm)?)" | 210 r"|(?:algo(?:rithm)?)" |
| 211 r"|(?:proc(?:edure)?)" | 211 r"|(?:proc(?:edure)?)" |
| 212 r"|(?:func(?:tion)?)" | 212 r"|(?:func(?:tion)?)" |
| 213 r"|(?:class)" | 213 r"|(?:class)" |
| 214 r")\s*(\{)", | 214 r")(?:_|(?:[\t -]+))?(\{)", |
| 215 bygroups(op_opt_end_translate(Keyword), | 215 bygroups(op_opt_end_translate(Keyword), |
| 216 op_opt_ignore_or_fixed(Whitespace, " ")), | 216 op_opt_ignore_or_fixed(Whitespace, " ")), |
| 217 "entity-name-end"), | 217 "entity-name-end"), |
| 218 # without name | 218 # without name |
| 219 (r"(?i)\\end(?:_|-)?(" | 219 (r"(?i)\\end(?:_|-)?(" |
| 253 ], | 253 ], |
| 254 "expr": [ | 254 "expr": [ |
| 255 include("punctuation"), | 255 include("punctuation"), |
| 256 include("py-strings"), | 256 include("py-strings"), |
| 257 include("py-numbers"), | 257 include("py-numbers"), |
| 258 (r"(?i)\\text\s*\{", LexBase.op_ignore, "text-in-expr"), | 258 (r"(?i)\\text[ \t]*\{", LexBase.op_ignore, "text-in-expr"), |
| 259 include("explicit-tokentype"), | 259 include("explicit-tokentype"), |
| 260 include("remark"), | 260 include("remark"), |
| 261 include("keyword-constants"), | 261 include("keyword-constants"), |
| 262 include("text-operators"), | 262 include("text-operators"), |
| 263 include("math-builtins"), | 263 include("math-builtins"), |
| 265 ], | 265 ], |
| 266 "expr-in-braces": [ | 266 "expr-in-braces": [ |
| 267 include("punctuation-in-braces"), | 267 include("punctuation-in-braces"), |
| 268 include("py-strings"), | 268 include("py-strings"), |
| 269 include("py-numbers"), | 269 include("py-numbers"), |
| 270 (r"(?i)\\text\s*\{", LexBase.op_ignore, "text-in-expr"), | 270 (r"(?i)\\text[ \t]*\{", LexBase.op_ignore, "text-in-expr"), |
| 271 include("explicit-tokentype"), | 271 include("explicit-tokentype"), |
| 272 include("remark"), | 272 include("remark"), |
| 273 include("keyword-constants"), | 273 include("keyword-constants"), |
| 274 include("text-operators"), | 274 include("text-operators"), |
| 275 include("math-builtins"), | 275 include("math-builtins"), |
| 286 "text-statement": [ # like block but default to text-mode | 286 "text-statement": [ # like block but default to text-mode |
| 287 (r"[^\\}\n]+", Text), | 287 (r"[^\\}\n]+", Text), |
| 288 (r"\}", LexBase.op_ignore, "#pop"), | 288 (r"\}", LexBase.op_ignore, "#pop"), |
| 289 (r"\n", Whitespace), | 289 (r"\n", Whitespace), |
| 290 (r"\\\}", LexBase.op_fixed(Text, "}")), | 290 (r"\\\}", LexBase.op_fixed(Text, "}")), |
| 291 (r"(?i)\\expr(?:ession)?\s*\{", | 291 (r"(?i)\\expr(?:ession)?[ \t]*\{", |
| 292 LexBase.op_ignore, | 292 LexBase.op_ignore, |
| 293 "block-expr"), | 293 "block-expr"), |
| 294 include("explicit-tokentype"), | 294 include("explicit-tokentype"), |
| 295 include("remark"), | 295 include("remark"), |
| 296 (r"\\\\", LexBase.op_fixed(Text, "\\")), | 296 (r"\\\\", LexBase.op_fixed(Text, "\\")), |
| 299 "text-in-expr": [ | 299 "text-in-expr": [ |
| 300 (r"[^\\}\n]+", Text), | 300 (r"[^\\}\n]+", Text), |
| 301 (r"\}", LexBase.op_ignore, "#pop"), | 301 (r"\}", LexBase.op_ignore, "#pop"), |
| 302 (r"\n", Whitespace), | 302 (r"\n", Whitespace), |
| 303 (r"\\\}", LexBase.op_fixed(Text, "}")), | 303 (r"\\\}", LexBase.op_fixed(Text, "}")), |
| 304 (r"(?:i)\\(expr(?:ession)?)\s*(\{)", | 304 (r"(?:i)\\(expr(?:ession)?)[ \t]*(\{)", |
| 305 bygroups(LexBase.op_ignore, LexBase.op_ignore), | 305 bygroups(LexBase.op_ignore, LexBase.op_ignore), |
| 306 "expr-in-braces"), | 306 "expr-in-braces"), |
| 307 include("explicit-tokentype"), | 307 include("explicit-tokentype"), |
| 308 (r"\\\\", LexBase.op_fixed(Text, "\\")), | 308 (r"\\\\", LexBase.op_fixed(Text, "\\")), |
| 309 (r"\\", LexBase.op_fixed(Text, "\\")), | 309 (r"\\", LexBase.op_fixed(Text, "\\")), |