From a70e0a59817ce06a3dd23b3750ae16ee6660deaf Mon Sep 17 00:00:00 2001 From: Sudipto Mallick <> Date: Tue, 2 Jan 2024 02:12:16 +0000 Subject: Add Java assignments to the repository .gitignore: The build files, files left by editors like *~ and the PDF documents for the assignments are to be ignored for the purposes of version control. README.rst: Rewrite, with one line description in Chinese. java/alist.txt: List of assignments, sorted in the order of the list of assignments, with the ones with completed documentation marked with `#`. java/buildall: Script that will build all of the assignments into one PDF file; to be rehauled for the final document. code/*.java: The Java source code for the assignments. dbld: Script that builds a PDF document for a single assignment. index.typ: The list of assignments, subject to update for further refinement and inclusion of yet more assignments. jbld: Script that compiles code for a single Java assignment. output/*.typ: Typst file containing the output (sessions) obtained from running the individual Java assignments. state.sql: Future alternative to `alist.txt`, under development. template.typ: The Typst template used across all of assignment, containing common code for the uniform styling, such as page border. text/*.typ: Typst file documenting each Java assignment. vendor/Java.sublime-syntax: Updated Sublime Text syntax file for Java, used for newer syntax features, such as `var`, not yet available in syntaxes shipped with Typst. vendor/gr.tmTheme: A grayscale TextMate theme to be used for code in the documents generated by Typst suitable for black and white printing. wltd: Difference between the files in `code/` and `text/`, and `code/` and `output`; need to be rewritten along with `state.sql`. --- java/vendor/Java.sublime-syntax | 1246 +++++++++++++++++++++++++++++++++++++++ java/vendor/gr.tmTheme | 566 ++++++++++++++++++ 2 files changed, 1812 insertions(+) create mode 100644 java/vendor/Java.sublime-syntax create mode 100644 java/vendor/gr.tmTheme (limited to 'java/vendor') diff --git a/java/vendor/Java.sublime-syntax b/java/vendor/Java.sublime-syntax new file mode 100644 index 0000000..c13c939 --- /dev/null +++ b/java/vendor/Java.sublime-syntax @@ -0,0 +1,1246 @@ +%YAML 1.2 +--- +# http://www.sublimetext.com/docs/3/syntax.html +name: java-new +file_extensions: + - java + - bsh +scope: source.java + +variables: + primitives: (?:boolean|byte|char|short|int|float|long|double|var) + storage_modifiers: (?:public|private|protected|static|final|native|synchronized|strictfp|abstract|transient|default|volatile) + + id: (?:[\p{L}_$][\p{L}\p{N}_$]*) + classcase_id: (?:\p{Lu}[\p{L}\p{N}_$]*) + lowercase_id: (?:[_$]*\p{Ll}[\p{Ll}\p{N}_$]*\b) + uppercase_id: (?:[_$]*\p{Lu}[\p{Lu}\p{N}_$]*\b) + + # One dot is mandatory to not compete with other regexes that match an id. + before_fqn: (?={{lowercase_id}}\s*\.) + + # utility lookaround + lambda_lookahead: (?:\(.*\)|{{id}})\s*-> + + # digits + ddigits0: '\d[\d_]*?(_*)' + ddigits: (?:(_*){{ddigits0}}) + hdigits: (?:(_*)\h[\h_]*?(_*)) + exponent: '[-+]?{{ddigits}}' + eexponent: (?:[eE]{{exponent}}) + pexponent: (?:[pP]{{exponent}}) + +contexts: + prototype: + - match: (?=%>) + pop: true + - include: comments + - include: illegal-keywords + + any_POP: + - match: (?=\S) + pop: true + + immediate_POP: + - match: '' + pop: true + + main: + - include: prototype + - include: package-statement + - include: import-statement + - include: module + - include: class + - include: annotations + # Get modifiers defined on a different line than the class + - include: storage-modifiers + - include: stray-braces + - include: code + + punctuation-accessor-dot: + - match: \. + scope: punctuation.accessor.dot.java + + punctuation-separator-comma: + - match: \, + scope: punctuation.separator.comma.java + + punctuation-terminator-semicolon: + - match: ; + scope: punctuation.terminator.java + + dot-separated-identifier: + - match: '{{id}}' + - include: punctuation-accessor-dot + - include: immediate_POP + + package-statement: + - match: \bpackage\b + scope: keyword.other.package.java + push: + - - meta_scope: meta.package-declaration.java + - include: immediate_POP + - - match: '{{id}}' + set: + - meta_scope: meta.path.java entity.name.namespace.java + - include: dot-separated-identifier + - include: any_POP + + import-statement: + - match: \bimport\b + scope: keyword.control.import.java + push: + - - meta_scope: meta.import.java + - include: immediate_POP + - import-statement-body + + import-statement-body: + - match: \bstatic\b + scope: keyword.control.import.static.java + set: static-import-statement-body + - include: before-next-import + - match: '{{lowercase_id}}' + scope: meta.path.java support.type.package.java + set: + - meta_content_scope: meta.path.java + - include: before-next-import + - include: package + - match: \* + scope: meta.path.java keyword.operator.wildcard.asterisk.java + pop: true + - match: '{{classcase_id}}' + scope: support.class.import.java + set: + - include: before-next-import + - include: punctuation-accessor-dot + - include: import-class + - include: import-wildcard + - include: any_POP + - include: any_POP + - include: any_POP + + static-import-statement-body: + - include: before-next-import + - match: '{{lowercase_id}}' + scope: meta.path.java support.type.package.java + set: + - meta_content_scope: meta.path.java + - include: before-next-import + - include: package + - match: '{{classcase_id}}' + scope: support.class.import.java + set: + - include: before-next-import + - include: punctuation-accessor-dot + - include: import-constant + - include: import-class + - include: import-function + - include: import-wildcard + - include: any_POP + - include: any_POP + - include: any_POP + + before-next-import: + # Prevent next import statement to be consumed when a current statement isn't terminated with ';'. + - match: (?=\bimport\b) + pop: true + # For a case of a statement immediately before a class definition. + - match: (?=\b(?:{{storage_modifiers}}|class|interface|enum)\b) + pop: true + + package: + - match: '{{lowercase_id}}' + scope: support.type.package.java + - include: punctuation-accessor-dot + + all-types: + - include: primitive-types + - include: object-types + + import-constant: + - match: '{{uppercase_id}}' + scope: constant.other.import.java + + import-class: + - match: '{{classcase_id}}' + scope: support.class.import.java + + import-function: + - match: '{{id}}' + scope: support.function.import.java + + import-wildcard: + - match: \* + scope: keyword.operator.wildcard.asterisk.java + + annotations: + - match: \@ + scope: punctuation.definition.annotation.java + push: + - - meta_scope: meta.annotation.java + - include: immediate_POP + - annotation-parameters + - - meta_content_scope: meta.annotation.identifier.java + - include: immediate_POP + - annotation-type-reference + + annotation-type-reference: + - match: '{{before_fqn}}' + set: + - meta_scope: meta.path.java + - match: '{{lowercase_id}}' + scope: variable.annotation.package.java + - include: punctuation-accessor-dot + - include: annotation-type-no-fqn + - include: annotation-type-no-fqn + + annotation-type-no-fqn: + - match: '{{classcase_id}}' + scope: variable.annotation.java + set: after-annotation-type-reference + - include: any_POP + + after-annotation-type-reference: + - match: \. + scope: punctuation.accessor.dot.java + set: annotation-type-no-fqn + - include: any_POP + + annotation-parameters: + - match: \( + scope: punctuation.section.parens.begin.java + set: + - meta_scope: meta.annotation.parameters.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - match: ({{id}})\s*(=) + captures: + 1: variable.parameter.java + 2: keyword.operator.assignment.java + push: + - match: (?=[,})]) + pop: true + - include: annotations + - include: code + - include: annotation-array-initialization + - include: annotations + - include: code + - include: any_POP + + annotation-array-initialization: + - match: \{ + scope: punctuation.section.braces.begin.java + push: + - meta_scope: meta.braces.annotation-array-initialization.java + - include: array-initialization-common + - include: annotations + + anonymous-classes-and-new: + - match: \bnew\b + scope: keyword.other.storage.new.java + push: + - - meta_scope: meta.instantiation.java + - include: immediate_POP + - instantiation + + instantiation: + - match: \b{{primitives}}\b + scope: storage.type.primitive.java + set: array-definition + - match: '{{before_fqn}}' + set: [after-object-type-in-instantiation, object-type-fqn] + - include: object-type-instantiation-no-fqn + + object-type-instantiation-no-fqn: + - match: '{{classcase_id}}' + scope: support.class.java + set: after-object-type-in-instantiation + - include: any_POP + + after-object-type-in-instantiation: + - match: (?=\[) + set: array-definition + - match: (?=\() + set: object-construction + - match: <> + scope: punctuation.definition.generic.diamond.java + set: object-construction + - match: (?=<) + set: [after-generic-in-instantiation, generic-type-invocation] + - match: \. + scope: punctuation.accessor.dot.java + set: object-type-instantiation-no-fqn + - include: any_POP + + after-generic-in-instantiation: + - match: (?=\[) + set: array-definition + - include: object-construction + + object-construction: + - match: \( + scope: punctuation.section.parens.begin.java + set: + - meta_scope: meta.parens.constructor-arguments.java + - match: \) + scope: punctuation.section.parens.end.java + set: + - match: \{ + scope: punctuation.section.braces.begin.java + set: + - meta_scope: meta.class.body.anonymous.java + - match: \} + scope: punctuation.section.braces.end.java + pop: true + - include: class-body + - include: any_POP + - include: illegal-parens-terminators + - include: code + - include: any_POP + + array-definition: + - match: \[ + scope: punctuation.section.brackets.begin.java + set: + - meta_scope: meta.brackets.array-initialization.java + - match: \] + scope: punctuation.section.brackets.end.java + set: + - match: (?=\[) + set: array-definition + - match: \{ + scope: punctuation.section.braces.begin.java + set: array-initialization + - include: any_POP + - include: code + - include: any_POP + + array-initialization: + - meta_scope: meta.braces.array-initialization.java + - include: array-initialization-common + + array-initialization-common: + - match: \} + scope: punctuation.section.braces.end.java + pop: true + - match: \{ + scope: punctuation.section.braces.begin.java + push: array-initialization + - include: code + + class: + - match: (?=({{storage_modifiers}}\s+)*(?:class|(?:@)?interface|enum)\b) + push: [class-meta, class-type] + + class-meta: + - meta_scope: meta.class.java + - include: immediate_POP + + class-type: + - include: storage-modifiers + - match: (?:class|(\@?)interface)\b + scope: storage.type.java + captures: + 1: punctuation.definition.type.java + set: + - class-block + - class-extends + - generic-type-declaration + - class-name + - match: enum\b + scope: storage.type.java + set: + - enum-block + - class-extends + - generic-type-declaration + - class-name + - include: any_POP + + class-name: + - meta_scope: meta.class.identifier.java + - match: (?!extends|implements){{id}}\b + scope: entity.name.class.java + pop: true + - include: any_POP + + class-extends: + - match: extends\b + scope: keyword.declaration.extends.java + push: + - - meta_scope: meta.class.extends.java + - match: \, + scope: punctuation.separator.comma.java + push: inherited-object-type-reference + - include: any_POP + - inherited-object-type-reference + - match: implements\b + scope: keyword.declaration.implements.java + push: + - - meta_scope: meta.class.implements.java + - match: \, + scope: punctuation.separator.comma.java + push: inherited-object-type-reference + - include: any_POP + - inherited-object-type-reference + - include: any_POP + + class-block: + - match: \{ + scope: punctuation.section.block.begin.java + set: + - meta_scope: meta.class.body.java meta.block.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: class-body + - include: any_POP + + class-body: + - include: class + - include: annotations + - include: fields-and-methods + - include: constants-and-special-vars + - include: storage-modifiers + - include: all-types + - include: static-code-block + - include: punctuation-separator-comma + - include: punctuation-terminator-semicolon + - match: (?=<) + push: generic-type-declaration + + enum-block: + - match: \{ + scope: punctuation.section.block.begin.java + set: + - meta_scope: meta.class.body.java meta.block.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: enum-body + - include: any_POP + + enum-body: + - match: ^(?=\s*([[:upper:]_][[:upper:][:digit:]_]*|(?!{{primitives}}|{{storage_modifiers}})[[:lower:]_][[:alnum:]_]*)\s*[,;{(]) + push: + - match: (?=[;}]) + pop: true + - match: \w+ + scope: constant.other.enum.java + push: + - meta_scope: meta.enum.java + - match: \{ + scope: punctuation.section.block.begin.java + push: + - meta_scope: meta.enum.body.java meta.block.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: enum-body + - include: parens + - include: any_POP + - include: punctuation-separator-comma + - include: class-body + + code: + - include: constants-and-special-vars + - include: assignment + - include: lambdas + - include: strings + - include: anonymous-classes-and-new + - include: keywords-control + - include: method-invocations + - include: uppercase-identifiers + - include: all-types + - include: keywords + - include: code-block-include + - include: parens + code-block-include: + - match: \{ + scope: punctuation.section.block.begin.java + push: + - meta_scope: meta.block.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: code-block + code-block: + - include: storage-modifiers + - include: var-type + - include: code + - include: annotations + - include: code-block-include + - include: stray-parens + comments: + - match: /\*\*/ + scope: comment.block.empty.java punctuation.definition.comment.java + - include: scope:text.html.javadoc + - include: comments-inline + comments-inline: + - match: /\* + scope: punctuation.definition.comment.java + push: + - meta_scope: comment.block.java + - match: \*/ + scope: punctuation.definition.comment.java + pop: true + - match: // + scope: punctuation.definition.comment.java + push: + - meta_scope: comment.line.double-slash.java + - match: \n + pop: true + - match: (?=%>) + pop: true + + constants-and-special-vars: + - match: \b(true|false|null)\b + scope: constant.language.java + - match: \b(this|super)\b + scope: variable.language.java + # hexadecimal floats + - match: |- + \b(0[xX])(?x: + # 0x1., 0x1.1, 0x1.1p1, 0x1.1p-1, 0x1.p1, 0x1.p-1 | 0x1p1 + {{hdigits}} (?: (\.) (?: {{hdigits}}? {{pexponent}}? \b )? | {{pexponent}} \b ) + # 0x.1, 0x.1p1, 0x.1p-1 + | (\.) {{hdigits}} {{pexponent}}? \b + ) + scope: constant.numeric.float.hexadecimal.java + captures: + 1: punctuation.definition.numeric.hexadecimal.java + 2: invalid.illegal.numeric.java + 3: invalid.illegal.numeric.java + 4: punctuation.separator.decimal.java + 5: invalid.illegal.numeric.java + 6: invalid.illegal.numeric.java + 7: invalid.illegal.numeric.java + 8: invalid.illegal.numeric.java + 9: invalid.illegal.numeric.java + 10: invalid.illegal.numeric.java + 11: punctuation.separator.decimal.java + 12: invalid.illegal.numeric.java + 13: invalid.illegal.numeric.java + 14: invalid.illegal.numeric.java + 15: invalid.illegal.numeric.java + # decimal floats + - match: |- + (?x: + \b{{ddigits0}} + (?: + # 1., 1.1, 1.1e1, 1.1e-1, 1.e1, 1.e-1, 1.d, 1.1d, 1.1e1d, 1.1e-1d, 1.e1d, 1.e-1d + (\.) (?: {{ddigits}}? {{eexponent}}? ([dDfF])? \b )? + # 1e1 1e1d + | {{eexponent}} ([dDfF])? \b + # 1d + | ([dDfF]) \b + ) + # .1, .1e1, .1e-1 + | (\.) {{ddigits}} {{eexponent}}? ([dDfF])? \b + ) + scope: constant.numeric.float.decimal.java + captures: + 1: invalid.illegal.numeric.java + 2: punctuation.separator.decimal.java + 3: invalid.illegal.numeric.java + 4: invalid.illegal.numeric.java + 5: invalid.illegal.numeric.java + 6: invalid.illegal.numeric.java + 7: storage.type.numeric.java + 8: invalid.illegal.numeric.java + 9: invalid.illegal.numeric.java + 10: storage.type.numeric.java + 11: storage.type.numeric.java + 12: punctuation.separator.decimal.java + 13: invalid.illegal.numeric.java + 14: invalid.illegal.numeric.java + 15: invalid.illegal.numeric.java + 16: invalid.illegal.numeric.java + 17: storage.type.numeric.java + # binary integers + - match: \b(0[bB])(_*)[01][01_]*?(_*)([lL])?\b + scope: constant.numeric.integer.binary.java + captures: + 1: punctuation.definition.numeric.binary.java + 2: invalid.illegal.numeric.java + 3: invalid.illegal.numeric.java + 4: storage.type.numeric.java + # hexadecimal integers + - match: \b(0[xX]){{hdigits}}([lL])?\b + scope: constant.numeric.integer.hexadecimal.java + captures: + 1: punctuation.definition.numeric.hexadecimal.java + 2: invalid.illegal.numeric.java + 3: invalid.illegal.numeric.java + 4: storage.type.numeric.java + # octal integers + - match: \b(0)(?:(_+)|[0-7_]+?(_*)|([\d_]+))([lL])?\b + scope: constant.numeric.integer.octal.java + captures: + 1: punctuation.definition.numeric.octal.java + 2: invalid.illegal.numeric.java + 3: invalid.illegal.numeric.java + 4: invalid.illegal.numeric.java + 5: storage.type.numeric.java + # decimal integers + - match: \b{{ddigits0}}([lL])?\b + scope: constant.numeric.integer.decimal.java + captures: + 1: invalid.illegal.numeric.java + 2: storage.type.numeric.java + + keywords: + - match: '::' + scope: punctuation.accessor.double-colon.java + push: + - match: '{{id}}' + scope: variable.function.reference.java + pop: true + - include: any_POP + - match: '\?|:' + scope: keyword.operator.ternary.java + - match: \binstanceof\b + scope: keyword.operator.word.instanceof.java + - match: (<<|>>>?) + scope: keyword.operator.bitshift.java + - match: (==|!=|<=|>=|<>|<|>) + scope: keyword.operator.comparison.java + - match: (\-\-|\+\+) + scope: keyword.operator.increment-decrement.java + - match: (\-|\+|\*|\/|%) + scope: keyword.operator.arithmetic.java + - match: (!|&&|\|\|) + scope: keyword.operator.logical.java + - match: (~|\^|&|\|) + scope: keyword.operator.bitwise.java + - match: (\.)(class\b)? + captures: + 1: punctuation.accessor.dot.java + 2: variable.language.java + - include: punctuation-separator-comma + - include: punctuation-terminator-semicolon + + keywords-control: + # exceptions + - match: \bcatch\b + scope: keyword.control.exception.catch.java + push: + - meta_scope: meta.catch.java + - match: (?=\() + set: + - match: \( + scope: punctuation.section.parens.begin.java + set: + - meta_scope: meta.catch.parameters.java meta.parens.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - match: \| + scope: punctuation.separator.bar.java + - include: parameters + - include: any_POP + - match: \bfinally\b + scope: keyword.control.exception.finally.java + - match: \btry\b + scope: keyword.control.exception.try.java + push: declaration-statement-parens + # flow + - match: \bassert\b + scope: keyword.control.flow.assert.java + push: + - meta_scope: meta.assertion.java + - match: (?=;) + pop: true + - match: ':' + scope: punctuation.separator.expressions.java + - include: code + - match: \bbreak\b + scope: keyword.control.flow.break.java + - match: \bcontinue\b + scope: keyword.control.flow.continue.java + - match: \breturn\b + scope: keyword.control.flow.return.java + - match: \bthrow\b + scope: keyword.control.flow.throw.java + # conditional + - match: \bif\b + scope: keyword.control.conditional.if.java + - match: \belse\b + scope: keyword.control.conditional.else.java + - match: \bswitch\b + scope: keyword.control.conditional.switch.java + - match: \bcase\b + scope: keyword.control.conditional.case.java + - match: \bdefault\b + scope: keyword.control.conditional.default.java + # loop + - match: \bdo\b + scope: keyword.control.loop.do-while.java + - match: \bfor\b + scope: keyword.control.loop.for.java + push: declaration-statement-parens + - match: \bwhile\b + scope: keyword.control.loop.while.java + + illegal-keywords: + - match: \b(goto|const)\b + scope: invalid.illegal.keyword.java + + illegal-open-block: + - match: \s?(?={) + scope: invalid.illegal.stray-terminator-end + pop: true + + illegal-semicolon: + - match: ; + scope: invalid.illegal.stray-terminator-end + pop: true + + illegal-parens-terminators: + # Pops the stack if anything matches + - include: illegal-semicolon + - include: illegal-open-block + + method-invocations: + - match: (\.)\s*(?=<) + captures: + 1: punctuation.accessor.dot.java + push: generic-type-invocation + - match: ({{id}})\s*(\() + captures: + 1: variable.function.java + 2: punctuation.section.parens.begin.java + push: + - meta_scope: meta.function-call.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - include: illegal-parens-terminators + - include: code + + fields-and-methods: + - match: \bvoid\b + scope: storage.type.void.java + push: method + - match: (?={{id}}\s*\() + push: method + - match: '{{before_fqn}}' + push: [field-or-method, after-object-and-array-types, object-type-fqn] + - match: \b{{classcase_id}} + scope: support.class.java + push: [field-or-method, after-object-and-array-types] + - match: \b{{primitives}}\b + scope: storage.type.primitive.java + push: [field-or-method, array-brackets] + + field-or-method: + - match: (?={{id}}\s*\() + set: method + - match: (?=\S) + set: + - include: before-next-field + - match: (?:({{uppercase_id}})|({{id}})) + captures: + 1: entity.name.constant.java + 2: meta.field.java + push: [static-assignment, array-brackets] + - include: punctuation-separator-comma + - include: any_POP + + before-next-field: + # Prevent style from being removed from whole file when making a new expression + - match: (?=\b(?:{{storage_modifiers}}|{{primitives}}|void)\b) + pop: true + + method: + - meta_scope: meta.method.java + - match: ({{classcase_id}})\s*(?=\() + captures: + 1: meta.method.identifier.java entity.name.function.constructor.java + - match: ({{id}})\s*(?=\() + captures: + 1: meta.method.identifier.java entity.name.function.java + - match: \( + scope: punctuation.section.parens.begin.java + push: + - meta_scope: meta.method.parameters.java meta.parens.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - include: parameters + - match: \S + scope: invalid.illegal.missing-parameter-end + pop: true + - include: throws + - include: annotation-default + - match: \{ + scope: punctuation.section.block.begin.java + set: + - meta_scope: meta.method.java meta.method.body.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: code-block + - include: any_POP + + throws: + - match: \bthrows\b + scope: keyword.declaration.throws.java + push: + - - meta_scope: meta.method.throws.java + - match: \, + scope: punctuation.separator.comma.java + push: object-type-reference + - include: any_POP + - object-type-reference + + # Stand-along uppercase id, either type or constant. + # Should be used only inside code blocks. + uppercase-identifiers: + # Popular JDK classes + - match: \b(?:UUID|UR[LI])\b + scope: support.class.java + push: after-object-type + # Generic type variable + - match: \b\p{Lu}\b + scope: support.class.java + push: after-object-type + # Uppercase constants + - match: \b{{uppercase_id}} + scope: constant.other.java + + # Stand-alone type, maybe type of the variable or class object reference. + # Should be used only inside code blocks. + object-types: + # Here the match is more complex than 'before_fqn'. + # In code block we can't simply distinguish package from variable. + - match: (?=\b(?:{{lowercase_id}}\.)+\p{Lu}) + push: [after-object-type, object-type-fqn] + - match: \b{{classcase_id}}\b + scope: support.class.java + push: after-object-type + + object-type-fqn: + - meta_scope: meta.path.java + - include: package + - match: '{{classcase_id}}' + scope: support.class.java + pop: true + - include: any_POP + + after-object-type: + - match: (?=<) + set: [array-brackets, generic-type-invocation] + - match: \.(?!\.) + scope: punctuation.accessor.dot.java + set: + - match: (?=<) + set: generic-type-invocation + - match: (?:(class)\b|({{uppercase_id}})) + captures: + 1: variable.language.java + 2: constant.other.java + pop: true + - match: '{{classcase_id}}' + scope: support.class.java + set: after-object-type + - include: any_POP + - include: array-brackets + + # Used in 'throws' and generic bounds + object-type-reference: + - match: '{{before_fqn}}' + set: + - meta_scope: meta.path.java + - include: package + - include: object-type-reference-no-fqn + - include: object-type-reference-no-fqn + + object-type-reference-no-fqn: + - match: '{{classcase_id}}' + scope: support.class.java + set: after-object-type-reference + - include: any_POP + + after-object-type-reference: + - match: (?=<) + set: generic-type-invocation + - match: \. + scope: punctuation.accessor.dot.java + set: object-type-reference-no-fqn + - include: any_POP + + # Used in method's and generic's parameters + object-and-array-types: + - match: '{{before_fqn}}' + push: + - meta_scope: meta.path.java + - include: package + - include: object-and-array-types-no-fqn + - match: \b({{primitives}})(?=\s*\[) + scope: storage.type.primitive.java + push: array-brackets + - match: \b{{classcase_id}} + scope: support.class.java + push: after-object-and-array-types + + object-and-array-types-no-fqn: + - match: '{{classcase_id}}' + scope: support.class.java + set: after-object-and-array-types + - include: any_POP + + after-object-and-array-types: + - match: (?=<) + set: [array-brackets, generic-type-invocation] + - match: \.(?!\.) + scope: punctuation.accessor.dot.java + set: object-and-array-types-no-fqn + - include: array-brackets + + # Used in class-level 'extends' and 'implements' + inherited-object-type-reference: + - match: '{{before_fqn}}' + set: + - meta_scope: meta.path.java + - match: '{{lowercase_id}}' + scope: entity.other.inherited-class.package.java + - include: punctuation-accessor-dot + - include: inherited-object-type-reference-no-fqn + - include: inherited-object-type-reference-no-fqn + + inherited-object-type-reference-no-fqn: + - match: (?!class|extends|implements|interface){{id}} + scope: entity.other.inherited-class.java + set: after-inherited-object-type-reference + - include: any_POP + + after-inherited-object-type-reference: + - match: (?=<) + set: generic-type-invocation + - match: \. + scope: punctuation.accessor.dot.java + set: inherited-object-type-reference-no-fqn + - include: any_POP + + generic-type-declaration: + - match: < + scope: punctuation.definition.generic.begin.java + push: generic-type-parameter + - include: any_POP + + generic-type-terminator: + - include: illegal-semicolon + # These characters can't appear in a generic. If we've matched + # them then someone forgot to close it. + - match: (?=[{}()]) + pop: true + - match: '>' + scope: punctuation.definition.generic.end.java + pop: true + + generic-type-parameter: + - meta_scope: meta.generic.declaration.java + - match: \b{{id}}\b + scope: variable.parameter.type.java + push: generic-type-bounds + - include: generic-type-terminator + + generic-type-bounds: + - match: (,)|(?=>) + captures: + 1: punctuation.separator.comma.java + pop: true + - match: \bextends\b + scope: keyword.declaration.extends.java + push: [generic-type-extends-multiple-bounds, object-type-reference] + - match: \bsuper\b + scope: keyword.declaration.super.java + push: object-type-reference + + generic-type-extends-multiple-bounds: + - match: '&' + scope: keyword.operator.multiple-bounds.java + set: [generic-type-extends-multiple-bounds, object-type-reference] + - include: any_POP + + generic-type-invocation: + - match: < + scope: punctuation.definition.generic.begin.java + set: generic-type-argument + - include: any_POP + + generic-type-argument: + - meta_scope: meta.generic.java + - match: \? + scope: keyword.operator.wildcard.java + push: generic-type-bounds + - include: generic-type-terminator + - include: object-and-array-types + - include: punctuation-separator-comma + + annotation-default: + - match: \bdefault\b + scope: keyword.declaration.default.java + push: + - meta_scope: meta.annotation.default.java + - match: (?=;) + pop: true + - include: code + + parameters: + - match: \bfinal\b + scope: storage.modifier.java + - include: annotations + - include: primitive-types + - include: object-and-array-types + - match: \.\.\. + scope: keyword.operator.variadic.java + - match: '{{id}}' + scope: variable.parameter.java + push: array-brackets + - include: punctuation-separator-comma + + lambdas: + - match: (?={{lambda_lookahead}}) + push: lambda-params + + lambda-params: + - meta_scope: meta.function.anonymous.parameters.java + - match: \( + scope: punctuation.section.parens.begin.java + set: + - meta_scope: meta.function.anonymous.parameters.java + - match: \) + scope: punctuation.section.parens.end.java + set: lambda-arrow + - include: parameters + - match: '{{id}}' + scope: variable.parameter.java + set: lambda-arrow + + lambda-arrow: + - match: -> + scope: storage.type.function.anonymous.java + set: + - meta_scope: meta.function.anonymous.body.java + - match: (?=[)};]) + pop: true + - include: code + + parens: + - match: \( + scope: punctuation.section.parens.begin.java + push: + - meta_scope: meta.parens.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - include: illegal-parens-terminators + - include: code + + declaration-statement-parens: + - match: \( + scope: punctuation.section.parens.begin.java + set: + - meta_scope: meta.parens.java + - match: \) + scope: punctuation.section.parens.end.java + pop: true + - include: illegal-open-block + - include: code-block + - include: any_POP + + primitive-types: + - match: \b{{primitives}}\b + scope: storage.type.primitive.java + push: array-brackets + + var-type: + - match: \bvar\b + scope: storage.type.var.java + + array-brackets: + - match: \[\s*\] + scope: storage.modifier.array.java + - include: any_POP + + static-assignment: + - match: \= + scope: keyword.operator.assignment.java + set: + - meta_scope: meta.assignment.rhs.java + - match: (?=[,;]) + pop: true + - include: before-next-field + - include: code + - include: stray-parens + - include: any_POP + + assignment: + - match: ([|&^*/+-]\=|\=(?!=)) + scope: keyword.operator.assignment.java + push: + - meta_scope: meta.assignment.rhs.java + - match: (?=;|\)|\}|,) + pop: true + - include: code + static-code-block: + - match: \{ + scope: punctuation.section.block.begin.java + push: + - meta_scope: meta.static.body.java + - match: \} + scope: punctuation.section.block.end.java + pop: true + - include: code-block + storage-modifiers: + - match: \b{{storage_modifiers}}\b + scope: storage.modifier.java + stray-braces: + - match: \} + scope: invalid.illegal.stray-brace-end + stray-parens: + - match: \) + scope: invalid.illegal.stray-parens-end + + strings: + - match: \" + scope: punctuation.definition.string.begin.java + push: + - meta_include_prototype: false + - meta_scope: string.quoted.double.java + - match: \" + scope: punctuation.definition.string.end.java + pop: true + - include: strings-common + - match: \' + scope: punctuation.definition.string.begin.java + push: + - meta_include_prototype: false + - meta_scope: string.quoted.single.java + - match: \' + scope: punctuation.definition.string.end.java + pop: true + - include: strings-common + + strings-common: + - match: \n + scope: invalid.illegal.newline.java + pop: true + - match: \\. + scope: constant.character.escape.java + + module: + - match: (?=\b(?:open\s+)?module\b) + push: + - - meta_scope: meta.module.java + - include: immediate_POP + - - match: \bopen\b + scope: storage.modifier.java + - match: \bmodule\b + scope: storage.type.java + set: [module-body, module-identifier-scope, module-identifier] + + module-identifier-scope: + - meta_scope: meta.module.identifier.java + - include: immediate_POP + + module-identifier: + - match: '{{id}}' + set: + - - meta_scope: entity.name.module.java + - include: immediate_POP + - dot-separated-identifier + - include: any_POP + + module-body: + - match: \{ + scope: punctuation.section.braces.begin.java + set: + - meta_scope: meta.module.body.java + - include: module-body-content + - match: \} + scope: punctuation.section.braces.end.java + pop: true + - include: any_POP + + module-body-content: + - match: \bexports\b + scope: keyword.other.module.exports.java + push: [exports-statement-scope, exports-or-opens-statement] + - match: \bopens\b + scope: keyword.other.module.opens.java + push: [opens-statement-scope, exports-or-opens-statement] + - match: \brequires\b + scope: keyword.other.module.requires.java + push: requires-statement + - match: \buses\b + scope: keyword.other.module.uses.java + push: [uses-statement-scope, object-type-reference] + - match: \bprovides\b + scope: keyword.other.module.provides.java + push: [provides-statement-scope, provides-with-statement, object-type-reference] + - include: punctuation-terminator-semicolon + + # Should always come before module/package patterns + module-statement-terminator: + - match: (?=[;\}]) + pop: true + - match: (?=\b(?:requires|exports|uses|provides|opens)\b) + pop: true + + support-type-module: + - match: '{{id}}' + push: + - - meta_scope: support.type.module.java + - include: immediate_POP + - dot-separated-identifier + + exports-statement-scope: + - meta_scope: meta.exports.java + - include: immediate_POP + + opens-statement-scope: + - meta_scope: meta.opens.java + - include: immediate_POP + + exports-or-opens-statement: + - match: \bto\b + scope: keyword.other.module.to.java + set: + - include: module-statement-terminator + - include: support-type-module + - include: punctuation-separator-comma + - include: module-statement-terminator + - match: '{{id}}' + push: + - - meta_scope: support.type.package.java + - include: immediate_POP + - dot-separated-identifier + + requires-statement: + - meta_scope: meta.requires.java + - match: \btransitive\b + scope: keyword.other.module.transitive.java + - include: module-statement-terminator + - include: support-type-module + + uses-statement-scope: + - meta_scope: meta.uses.java + - include: immediate_POP + + provides-statement-scope: + - meta_scope: meta.provides.java + - include: immediate_POP + + provides-with-statement: + - match: \bwith\b + scope: keyword.other.module.with.java + set: + - - match: \, + scope: punctuation.separator.comma.java + push: object-type-reference + - include: any_POP + - object-type-reference + - include: any_POP diff --git a/java/vendor/gr.tmTheme b/java/vendor/gr.tmTheme new file mode 100644 index 0000000..c4ab8f1 --- /dev/null +++ b/java/vendor/gr.tmTheme @@ -0,0 +1,566 @@ + + + + + author + Template: Chris Kempson, Scheme: Alexandre Gavioli (https://github.com/Alexx2/) + name + Base16 Grayscale Light + semanticClass + theme.base16.grayscale-light + colorSpaceName + sRGB + gutterSettings + + background + #e3e3e3 + divider + #e3e3e3 + foreground + #ababab + selectionBackground + #b9b9b9 + selectionForeground + #525252 + + settings + + + settings + + background + #f7f7f7 + caret + #464646 + foreground + #464646 + invisibles + #ababab + lineHighlight + #ababab55 + selection + #b9b9b9 + + + + name + Text + scope + variable.parameter.function + settings + + foreground + #222222 + + + + name + Comments + scope + comment, punctuation.definition.comment + settings + + foreground + #777777 + fontStyle + bold + + + + name + Punctuation + scope + punctuation.definition.string, punctuation.definition.variable, punctuation.definition.string, punctuation.definition.parameters, punctuation.definition.string, punctuation.definition.array + settings + + foreground + #111111 + + + + name + Delimiters + scope + none + settings + + foreground + #222222 + + + + name + Operators + scope + keyword.operator + settings + + foreground + #222222 + + + + name + Keywords + scope + keyword + settings + + foreground + #333333 + fontStyle + bold + + + + name + Variables + scope + variable + settings + + foreground + #555555 + + + + name + Functions + scope + entity.name.function, meta.require, support.function.any-method, variable.function, variable.annotation, support.macro + settings + + foreground + #444444 + + + + name + Labels + scope + entity.name.label + settings + + foreground + #5e5e5e + + + + name + Classes + scope + support.class, entity.name.class, entity.name.type.class + settings + + foreground + #666666 + + + + name + Classes + scope + meta.class + settings + + foreground + #101010 + + + + name + Methods + scope + keyword.other.special-method + settings + + foreground + #444444 + + + + name + Storage + scope + storage + settings + + foreground + #444444 + fontStyle + bold + + + + name + Support + scope + support.function + settings + + foreground + #868686 + + + + name + Strings, Inherited Class + scope + string, constant.other.symbol, entity.other.inherited-class + settings + + foreground + #333333 + + + + name + Integers + scope + constant.numeric + settings + + foreground + #000000 + + + + name + Floats + scope + none + settings + + foreground + #000000 + + + + name + Boolean + scope + none + settings + + foreground + #222222 + + + + name + Constants + scope + constant + settings + + foreground + #000000 + + + + name + Tags + scope + entity.name.tag + settings + + foreground + #7c7c7c + + + + name + Attributes + scope + entity.other.attribute-name + settings + + foreground + #999999 + + + + name + Attribute IDs + scope + entity.other.attribute-name.id, punctuation.definition.entity + settings + + foreground + #686868 + + + + name + Selector + scope + meta.selector + settings + + foreground + #747474 + + + + name + Values + scope + none + settings + + foreground + #999999 + + + + name + Headings + scope + markup.heading punctuation.definition.heading, entity.name.section + settings + + fontStyle + + foreground + #686868 + + + + name + Units + scope + keyword.other.unit + settings + + foreground + #999999 + + + + name + Bold + scope + markup.bold, punctuation.definition.bold + settings + + fontStyle + bold + foreground + #a0a0a0 + + + + name + Italic + scope + markup.italic, punctuation.definition.italic + settings + + fontStyle + italic + foreground + #747474 + + + + name + Code + scope + markup.raw.inline + settings + + foreground + #8e8e8e + + + + name + Link Text + scope + string.other.link, punctuation.definition.string.end.markdown, punctuation.definition.string.begin.markdown + settings + + foreground + #7c7c7c + + + + name + Link Url + scope + meta.link + settings + + foreground + #999999 + + + + name + Lists + scope + markup.list + settings + + foreground + #7c7c7c + + + + name + Quotes + scope + markup.quote + settings + + foreground + #999999 + + + + name + Separator + scope + meta.separator + settings + + background + #b9b9b9 + foreground + #464646 + + + + name + Inserted + scope + markup.inserted + settings + + foreground + #8e8e8e + + + + name + Deleted + scope + markup.deleted + settings + + foreground + #7c7c7c + + + + name + Changed + scope + markup.changed + settings + + foreground + #747474 + + + + name + Colors + scope + constant.other.color + settings + + foreground + #868686 + + + + name + Regular Expressions + scope + string.regexp + settings + + foreground + #868686 + + + + name + Escape Characters + scope + constant.character.escape + settings + + foreground + #868686 + + + + name + Embedded + scope + punctuation.section.embedded, variable.interpolation + settings + + foreground + #747474 + + + + name + Illegal + scope + invalid.illegal + settings + + background + #7c7c7c + foreground + #101010 + + + + name + Broken + scope + invalid.broken + settings + + background + #999999 + foreground + #f7f7f7 + + + + name + Deprecated + scope + invalid.deprecated + settings + + background + #5e5e5e + foreground + #101010 + + + + name + Unimplemented + scope + invalid.unimplemented + settings + + background + #ababab + foreground + #101010 + + + + uuid + uuid + + -- cgit 1.4.1-2-gfad0