spdx_tools.spdx.parser.tagvalue.lexer

  1# Copyright (c) 2014 Ahmed H. Ismail
  2# Copyright (c) 2023 spdx contributors
  3# SPDX-License-Identifier: Apache-2.0
  4# Licensed under the Apache License, Version 2.0 (the "License");
  5# you may not use this file except in compliance with the License.
  6# You may obtain a copy of the License at
  7#     http://www.apache.org/licenses/LICENSE-2.0
  8# Unless required by applicable law or agreed to in writing, software
  9# distributed under the License is distributed on an "AS IS" BASIS,
 10# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 11# See the License for the specific language governing permissions and
 12# limitations under the License.
 13
 14from ply import lex
 15from ply.lex import TOKEN
 16
 17
 18class SPDXLexer:
 19    reserved = {
 20        # Top level fields
 21        "SPDXVersion": "DOC_VERSION",
 22        "DataLicense": "DOC_LICENSE",
 23        "DocumentName": "DOC_NAME",
 24        "SPDXID": "SPDX_ID",
 25        "DocumentComment": "DOC_COMMENT",
 26        "DocumentNamespace": "DOC_NAMESPACE",
 27        "ExternalDocumentRef": "EXT_DOC_REF",
 28        # Creation info fields
 29        "Creator": "CREATOR",
 30        "Created": "CREATED",
 31        "CreatorComment": "CREATOR_COMMENT",
 32        "LicenseListVersion": "LICENSE_LIST_VERSION",
 33        # Annotation fields
 34        "Annotator": "ANNOTATOR",
 35        "AnnotationDate": "ANNOTATION_DATE",
 36        "AnnotationComment": "ANNOTATION_COMMENT",
 37        "AnnotationType": "ANNOTATION_TYPE",
 38        "SPDXREF": "ANNOTATION_SPDX_ID",
 39        # Relationship fields
 40        "Relationship": "RELATIONSHIP",
 41        "RelationshipComment": "RELATIONSHIP_COMMENT",
 42        # Package fields
 43        "PackageName": "PKG_NAME",
 44        "PackageVersion": "PKG_VERSION",
 45        "PackageDownloadLocation": "PKG_DOWNLOAD_LOCATION",
 46        "FilesAnalyzed": "PKG_FILES_ANALYZED",
 47        "PackageSummary": "PKG_SUMMARY",
 48        "PackageSourceInfo": "PKG_SOURCE_INFO",
 49        "PackageFileName": "PKG_FILE_NAME",
 50        "PackageSupplier": "PKG_SUPPLIER",
 51        "PackageOriginator": "PKG_ORIGINATOR",
 52        "PackageChecksum": "PKG_CHECKSUM",
 53        "PackageVerificationCode": "PKG_VERIFICATION_CODE",
 54        "PackageDescription": "PKG_DESCRIPTION",
 55        "PackageComment": "PKG_COMMENT",
 56        "PackageLicenseDeclared": "PKG_LICENSE_DECLARED",
 57        "PackageLicenseConcluded": "PKG_LICENSE_CONCLUDED",
 58        "PackageLicenseInfoFromFiles": "PKG_LICENSE_INFO",
 59        "PackageLicenseComments": "PKG_LICENSE_COMMENT",
 60        "PackageCopyrightText": "PKG_COPYRIGHT_TEXT",
 61        "PackageHomePage": "PKG_HOMEPAGE",
 62        "ExternalRef": "PKG_EXTERNAL_REF",
 63        "ExternalRefComment": "PKG_EXTERNAL_REF_COMMENT",
 64        "PackageAttributionText": "PKG_ATTRIBUTION_TEXT",
 65        "PrimaryPackagePurpose": "PRIMARY_PACKAGE_PURPOSE",
 66        "BuiltDate": "BUILT_DATE",
 67        "ReleaseDate": "RELEASE_DATE",
 68        "ValidUntilDate": "VALID_UNTIL_DATE",
 69        # File fields
 70        "FileName": "FILE_NAME",
 71        "FileType": "FILE_TYPE",
 72        "FileChecksum": "FILE_CHECKSUM",
 73        "LicenseConcluded": "FILE_LICENSE_CONCLUDED",
 74        "LicenseInfoInFile": "FILE_LICENSE_INFO",
 75        "FileCopyrightText": "FILE_COPYRIGHT_TEXT",
 76        "LicenseComments": "FILE_LICENSE_COMMENT",
 77        "FileComment": "FILE_COMMENT",
 78        "FileNotice": "FILE_NOTICE",
 79        "FileContributor": "FILE_CONTRIBUTOR",
 80        "FileAttributionText": "FILE_ATTRIBUTION_TEXT",
 81        # ExtractedLicensingInfo fields
 82        "LicenseID": "LICENSE_ID",
 83        "ExtractedText": "LICENSE_TEXT",
 84        "LicenseName": "LICENSE_NAME",
 85        "LicenseCrossReference": "LICENSE_CROSS_REF",
 86        "LicenseComment": "LICENSE_COMMENT",
 87        # Snippet fields
 88        "SnippetSPDXID": "SNIPPET_SPDX_ID",
 89        "SnippetName": "SNIPPET_NAME",
 90        "SnippetComment": "SNIPPET_COMMENT",
 91        "SnippetCopyrightText": "SNIPPET_COPYRIGHT_TEXT",
 92        "SnippetLicenseComments": "SNIPPET_LICENSE_COMMENT",
 93        "SnippetFromFileSPDXID": "SNIPPET_FILE_SPDXID",
 94        "SnippetLicenseConcluded": "SNIPPET_LICENSE_CONCLUDED",
 95        "LicenseInfoInSnippet": "SNIPPET_LICENSE_INFO",
 96        "SnippetAttributionText": "SNIPPET_ATTRIBUTION_TEXT",
 97        "SnippetByteRange": "SNIPPET_BYTE_RANGE",
 98        "SnippetLineRange": "SNIPPET_LINE_RANGE",
 99        # Common fields
100        "NOASSERTION": "NO_ASSERTION",
101        "NONE": "NONE",
102    }
103    states = (("text", "exclusive"),)
104
105    tokens = [
106        "TEXT",
107        "TOOL_VALUE",
108        "UNKNOWN_TAG",
109        "ORGANIZATION_VALUE",
110        "PERSON_VALUE",
111        "ISO8601_DATE",
112        "LINE",
113        "CHECKSUM",
114    ] + list(reserved.values())
115
116    def __init__(self):
117        self.lexer = None
118
119    @TOKEN(r":\s*<text>")
120    def t_text(self, t):
121        t.lexer.text_start = t.lexer.lexpos - len("<text>")
122        t.lexer.begin("text")
123
124    @TOKEN(r"</text>\s*")
125    def t_text_end(self, t):
126        t.type = "TEXT"
127        t.value = t.lexer.lexdata[t.lexer.text_start : t.lexer.lexpos]
128        t.lexer.lineno += t.value.count("\n")
129        t.value = t.value.strip()
130        t.lexer.begin("INITIAL")
131        return t
132
133    @TOKEN(r".|\n")
134    def t_text_any(self, t):
135        pass
136
137    def t_text_error(self, t):
138        print("Lexer error in text state")
139
140    @TOKEN(
141        r":\s*(ADLER32|BLAKE2b-256|BLAKE2b-384|BLAKE2b-512|BLAKE3|MD2|MD4|MD5|MD6|SHA1|SHA224|SHA256|SHA384|SHA512|"
142        r"SHA3-256|SHA3-384|SHA3-512):\s*([a-f0-9]*)"
143    )
144    def t_CHECKSUM(self, t):
145        t.value = t.value[1:].strip()
146        return t
147
148    @TOKEN(r":\s*Tool:.+")
149    def t_TOOL_VALUE(self, t):
150        t.value = t.value[1:].strip()
151        return t
152
153    @TOKEN(r":\s*Organization:.+")
154    def t_ORGANIZATION_VALUE(self, t):
155        t.value = t.value[1:].strip()
156        return t
157
158    @TOKEN(r":\s*Person:.+")
159    def t_PERSON_VALUE(self, t):
160        t.value = t.value[1:].strip()
161        return t
162
163    @TOKEN(r":\s*\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ")
164    def t_ISO8601_DATE(self, t):
165        t.value = t.value[1:].strip()
166        return t
167
168    @TOKEN(r"[a-zA-Z]+")
169    def t_KEYWORD_AS_TAG(self, t):
170        t.type = self.reserved.get(t.value, "UNKNOWN_TAG")
171        t.value = t.value.strip()
172        return t
173
174    @TOKEN(r":.+")
175    def t_LINE_OR_KEYWORD_VALUE(self, t):
176        t.value = t.value[1:].strip()
177        if t.value in self.reserved.keys():
178            t.type = self.reserved[t.value]
179        else:
180            t.type = "LINE"
181        return t
182
183    @TOKEN(r"\#.*")
184    def t_comment(self, t):
185        pass
186
187    @TOKEN(r"\n+")
188    def t_newline(self, t):
189        t.lexer.lineno += len(t.value)
190
191    @TOKEN(r"[ \t]+")
192    def t_whitespace(self, t):
193        pass
194
195    def build(self, **kwargs):
196        self.lexer = lex.lex(module=self, **kwargs)
197
198    def token(self):
199        return self.lexer.token()
200
201    def input(self, data):
202        self.lexer.input(data)
203
204    def t_error(self, t):
205        t.lexer.skip(1)
206        t.value = "Lexer error"
207        return t
class SPDXLexer:
 19class SPDXLexer:
 20    reserved = {
 21        # Top level fields
 22        "SPDXVersion": "DOC_VERSION",
 23        "DataLicense": "DOC_LICENSE",
 24        "DocumentName": "DOC_NAME",
 25        "SPDXID": "SPDX_ID",
 26        "DocumentComment": "DOC_COMMENT",
 27        "DocumentNamespace": "DOC_NAMESPACE",
 28        "ExternalDocumentRef": "EXT_DOC_REF",
 29        # Creation info fields
 30        "Creator": "CREATOR",
 31        "Created": "CREATED",
 32        "CreatorComment": "CREATOR_COMMENT",
 33        "LicenseListVersion": "LICENSE_LIST_VERSION",
 34        # Annotation fields
 35        "Annotator": "ANNOTATOR",
 36        "AnnotationDate": "ANNOTATION_DATE",
 37        "AnnotationComment": "ANNOTATION_COMMENT",
 38        "AnnotationType": "ANNOTATION_TYPE",
 39        "SPDXREF": "ANNOTATION_SPDX_ID",
 40        # Relationship fields
 41        "Relationship": "RELATIONSHIP",
 42        "RelationshipComment": "RELATIONSHIP_COMMENT",
 43        # Package fields
 44        "PackageName": "PKG_NAME",
 45        "PackageVersion": "PKG_VERSION",
 46        "PackageDownloadLocation": "PKG_DOWNLOAD_LOCATION",
 47        "FilesAnalyzed": "PKG_FILES_ANALYZED",
 48        "PackageSummary": "PKG_SUMMARY",
 49        "PackageSourceInfo": "PKG_SOURCE_INFO",
 50        "PackageFileName": "PKG_FILE_NAME",
 51        "PackageSupplier": "PKG_SUPPLIER",
 52        "PackageOriginator": "PKG_ORIGINATOR",
 53        "PackageChecksum": "PKG_CHECKSUM",
 54        "PackageVerificationCode": "PKG_VERIFICATION_CODE",
 55        "PackageDescription": "PKG_DESCRIPTION",
 56        "PackageComment": "PKG_COMMENT",
 57        "PackageLicenseDeclared": "PKG_LICENSE_DECLARED",
 58        "PackageLicenseConcluded": "PKG_LICENSE_CONCLUDED",
 59        "PackageLicenseInfoFromFiles": "PKG_LICENSE_INFO",
 60        "PackageLicenseComments": "PKG_LICENSE_COMMENT",
 61        "PackageCopyrightText": "PKG_COPYRIGHT_TEXT",
 62        "PackageHomePage": "PKG_HOMEPAGE",
 63        "ExternalRef": "PKG_EXTERNAL_REF",
 64        "ExternalRefComment": "PKG_EXTERNAL_REF_COMMENT",
 65        "PackageAttributionText": "PKG_ATTRIBUTION_TEXT",
 66        "PrimaryPackagePurpose": "PRIMARY_PACKAGE_PURPOSE",
 67        "BuiltDate": "BUILT_DATE",
 68        "ReleaseDate": "RELEASE_DATE",
 69        "ValidUntilDate": "VALID_UNTIL_DATE",
 70        # File fields
 71        "FileName": "FILE_NAME",
 72        "FileType": "FILE_TYPE",
 73        "FileChecksum": "FILE_CHECKSUM",
 74        "LicenseConcluded": "FILE_LICENSE_CONCLUDED",
 75        "LicenseInfoInFile": "FILE_LICENSE_INFO",
 76        "FileCopyrightText": "FILE_COPYRIGHT_TEXT",
 77        "LicenseComments": "FILE_LICENSE_COMMENT",
 78        "FileComment": "FILE_COMMENT",
 79        "FileNotice": "FILE_NOTICE",
 80        "FileContributor": "FILE_CONTRIBUTOR",
 81        "FileAttributionText": "FILE_ATTRIBUTION_TEXT",
 82        # ExtractedLicensingInfo fields
 83        "LicenseID": "LICENSE_ID",
 84        "ExtractedText": "LICENSE_TEXT",
 85        "LicenseName": "LICENSE_NAME",
 86        "LicenseCrossReference": "LICENSE_CROSS_REF",
 87        "LicenseComment": "LICENSE_COMMENT",
 88        # Snippet fields
 89        "SnippetSPDXID": "SNIPPET_SPDX_ID",
 90        "SnippetName": "SNIPPET_NAME",
 91        "SnippetComment": "SNIPPET_COMMENT",
 92        "SnippetCopyrightText": "SNIPPET_COPYRIGHT_TEXT",
 93        "SnippetLicenseComments": "SNIPPET_LICENSE_COMMENT",
 94        "SnippetFromFileSPDXID": "SNIPPET_FILE_SPDXID",
 95        "SnippetLicenseConcluded": "SNIPPET_LICENSE_CONCLUDED",
 96        "LicenseInfoInSnippet": "SNIPPET_LICENSE_INFO",
 97        "SnippetAttributionText": "SNIPPET_ATTRIBUTION_TEXT",
 98        "SnippetByteRange": "SNIPPET_BYTE_RANGE",
 99        "SnippetLineRange": "SNIPPET_LINE_RANGE",
100        # Common fields
101        "NOASSERTION": "NO_ASSERTION",
102        "NONE": "NONE",
103    }
104    states = (("text", "exclusive"),)
105
106    tokens = [
107        "TEXT",
108        "TOOL_VALUE",
109        "UNKNOWN_TAG",
110        "ORGANIZATION_VALUE",
111        "PERSON_VALUE",
112        "ISO8601_DATE",
113        "LINE",
114        "CHECKSUM",
115    ] + list(reserved.values())
116
117    def __init__(self):
118        self.lexer = None
119
120    @TOKEN(r":\s*<text>")
121    def t_text(self, t):
122        t.lexer.text_start = t.lexer.lexpos - len("<text>")
123        t.lexer.begin("text")
124
125    @TOKEN(r"</text>\s*")
126    def t_text_end(self, t):
127        t.type = "TEXT"
128        t.value = t.lexer.lexdata[t.lexer.text_start : t.lexer.lexpos]
129        t.lexer.lineno += t.value.count("\n")
130        t.value = t.value.strip()
131        t.lexer.begin("INITIAL")
132        return t
133
134    @TOKEN(r".|\n")
135    def t_text_any(self, t):
136        pass
137
138    def t_text_error(self, t):
139        print("Lexer error in text state")
140
141    @TOKEN(
142        r":\s*(ADLER32|BLAKE2b-256|BLAKE2b-384|BLAKE2b-512|BLAKE3|MD2|MD4|MD5|MD6|SHA1|SHA224|SHA256|SHA384|SHA512|"
143        r"SHA3-256|SHA3-384|SHA3-512):\s*([a-f0-9]*)"
144    )
145    def t_CHECKSUM(self, t):
146        t.value = t.value[1:].strip()
147        return t
148
149    @TOKEN(r":\s*Tool:.+")
150    def t_TOOL_VALUE(self, t):
151        t.value = t.value[1:].strip()
152        return t
153
154    @TOKEN(r":\s*Organization:.+")
155    def t_ORGANIZATION_VALUE(self, t):
156        t.value = t.value[1:].strip()
157        return t
158
159    @TOKEN(r":\s*Person:.+")
160    def t_PERSON_VALUE(self, t):
161        t.value = t.value[1:].strip()
162        return t
163
164    @TOKEN(r":\s*\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ")
165    def t_ISO8601_DATE(self, t):
166        t.value = t.value[1:].strip()
167        return t
168
169    @TOKEN(r"[a-zA-Z]+")
170    def t_KEYWORD_AS_TAG(self, t):
171        t.type = self.reserved.get(t.value, "UNKNOWN_TAG")
172        t.value = t.value.strip()
173        return t
174
175    @TOKEN(r":.+")
176    def t_LINE_OR_KEYWORD_VALUE(self, t):
177        t.value = t.value[1:].strip()
178        if t.value in self.reserved.keys():
179            t.type = self.reserved[t.value]
180        else:
181            t.type = "LINE"
182        return t
183
184    @TOKEN(r"\#.*")
185    def t_comment(self, t):
186        pass
187
188    @TOKEN(r"\n+")
189    def t_newline(self, t):
190        t.lexer.lineno += len(t.value)
191
192    @TOKEN(r"[ \t]+")
193    def t_whitespace(self, t):
194        pass
195
196    def build(self, **kwargs):
197        self.lexer = lex.lex(module=self, **kwargs)
198
199    def token(self):
200        return self.lexer.token()
201
202    def input(self, data):
203        self.lexer.input(data)
204
205    def t_error(self, t):
206        t.lexer.skip(1)
207        t.value = "Lexer error"
208        return t
reserved = {'SPDXVersion': 'DOC_VERSION', 'DataLicense': 'DOC_LICENSE', 'DocumentName': 'DOC_NAME', 'SPDXID': 'SPDX_ID', 'DocumentComment': 'DOC_COMMENT', 'DocumentNamespace': 'DOC_NAMESPACE', 'ExternalDocumentRef': 'EXT_DOC_REF', 'Creator': 'CREATOR', 'Created': 'CREATED', 'CreatorComment': 'CREATOR_COMMENT', 'LicenseListVersion': 'LICENSE_LIST_VERSION', 'Annotator': 'ANNOTATOR', 'AnnotationDate': 'ANNOTATION_DATE', 'AnnotationComment': 'ANNOTATION_COMMENT', 'AnnotationType': 'ANNOTATION_TYPE', 'SPDXREF': 'ANNOTATION_SPDX_ID', 'Relationship': 'RELATIONSHIP', 'RelationshipComment': 'RELATIONSHIP_COMMENT', 'PackageName': 'PKG_NAME', 'PackageVersion': 'PKG_VERSION', 'PackageDownloadLocation': 'PKG_DOWNLOAD_LOCATION', 'FilesAnalyzed': 'PKG_FILES_ANALYZED', 'PackageSummary': 'PKG_SUMMARY', 'PackageSourceInfo': 'PKG_SOURCE_INFO', 'PackageFileName': 'PKG_FILE_NAME', 'PackageSupplier': 'PKG_SUPPLIER', 'PackageOriginator': 'PKG_ORIGINATOR', 'PackageChecksum': 'PKG_CHECKSUM', 'PackageVerificationCode': 'PKG_VERIFICATION_CODE', 'PackageDescription': 'PKG_DESCRIPTION', 'PackageComment': 'PKG_COMMENT', 'PackageLicenseDeclared': 'PKG_LICENSE_DECLARED', 'PackageLicenseConcluded': 'PKG_LICENSE_CONCLUDED', 'PackageLicenseInfoFromFiles': 'PKG_LICENSE_INFO', 'PackageLicenseComments': 'PKG_LICENSE_COMMENT', 'PackageCopyrightText': 'PKG_COPYRIGHT_TEXT', 'PackageHomePage': 'PKG_HOMEPAGE', 'ExternalRef': 'PKG_EXTERNAL_REF', 'ExternalRefComment': 'PKG_EXTERNAL_REF_COMMENT', 'PackageAttributionText': 'PKG_ATTRIBUTION_TEXT', 'PrimaryPackagePurpose': 'PRIMARY_PACKAGE_PURPOSE', 'BuiltDate': 'BUILT_DATE', 'ReleaseDate': 'RELEASE_DATE', 'ValidUntilDate': 'VALID_UNTIL_DATE', 'FileName': 'FILE_NAME', 'FileType': 'FILE_TYPE', 'FileChecksum': 'FILE_CHECKSUM', 'LicenseConcluded': 'FILE_LICENSE_CONCLUDED', 'LicenseInfoInFile': 'FILE_LICENSE_INFO', 'FileCopyrightText': 'FILE_COPYRIGHT_TEXT', 'LicenseComments': 'FILE_LICENSE_COMMENT', 'FileComment': 'FILE_COMMENT', 'FileNotice': 'FILE_NOTICE', 'FileContributor': 'FILE_CONTRIBUTOR', 'FileAttributionText': 'FILE_ATTRIBUTION_TEXT', 'LicenseID': 'LICENSE_ID', 'ExtractedText': 'LICENSE_TEXT', 'LicenseName': 'LICENSE_NAME', 'LicenseCrossReference': 'LICENSE_CROSS_REF', 'LicenseComment': 'LICENSE_COMMENT', 'SnippetSPDXID': 'SNIPPET_SPDX_ID', 'SnippetName': 'SNIPPET_NAME', 'SnippetComment': 'SNIPPET_COMMENT', 'SnippetCopyrightText': 'SNIPPET_COPYRIGHT_TEXT', 'SnippetLicenseComments': 'SNIPPET_LICENSE_COMMENT', 'SnippetFromFileSPDXID': 'SNIPPET_FILE_SPDXID', 'SnippetLicenseConcluded': 'SNIPPET_LICENSE_CONCLUDED', 'LicenseInfoInSnippet': 'SNIPPET_LICENSE_INFO', 'SnippetAttributionText': 'SNIPPET_ATTRIBUTION_TEXT', 'SnippetByteRange': 'SNIPPET_BYTE_RANGE', 'SnippetLineRange': 'SNIPPET_LINE_RANGE', 'NOASSERTION': 'NO_ASSERTION', 'NONE': 'NONE'}
states = (('text', 'exclusive'),)
tokens = ['TEXT', 'TOOL_VALUE', 'UNKNOWN_TAG', 'ORGANIZATION_VALUE', 'PERSON_VALUE', 'ISO8601_DATE', 'LINE', 'CHECKSUM', 'DOC_VERSION', 'DOC_LICENSE', 'DOC_NAME', 'SPDX_ID', 'DOC_COMMENT', 'DOC_NAMESPACE', 'EXT_DOC_REF', 'CREATOR', 'CREATED', 'CREATOR_COMMENT', 'LICENSE_LIST_VERSION', 'ANNOTATOR', 'ANNOTATION_DATE', 'ANNOTATION_COMMENT', 'ANNOTATION_TYPE', 'ANNOTATION_SPDX_ID', 'RELATIONSHIP', 'RELATIONSHIP_COMMENT', 'PKG_NAME', 'PKG_VERSION', 'PKG_DOWNLOAD_LOCATION', 'PKG_FILES_ANALYZED', 'PKG_SUMMARY', 'PKG_SOURCE_INFO', 'PKG_FILE_NAME', 'PKG_SUPPLIER', 'PKG_ORIGINATOR', 'PKG_CHECKSUM', 'PKG_VERIFICATION_CODE', 'PKG_DESCRIPTION', 'PKG_COMMENT', 'PKG_LICENSE_DECLARED', 'PKG_LICENSE_CONCLUDED', 'PKG_LICENSE_INFO', 'PKG_LICENSE_COMMENT', 'PKG_COPYRIGHT_TEXT', 'PKG_HOMEPAGE', 'PKG_EXTERNAL_REF', 'PKG_EXTERNAL_REF_COMMENT', 'PKG_ATTRIBUTION_TEXT', 'PRIMARY_PACKAGE_PURPOSE', 'BUILT_DATE', 'RELEASE_DATE', 'VALID_UNTIL_DATE', 'FILE_NAME', 'FILE_TYPE', 'FILE_CHECKSUM', 'FILE_LICENSE_CONCLUDED', 'FILE_LICENSE_INFO', 'FILE_COPYRIGHT_TEXT', 'FILE_LICENSE_COMMENT', 'FILE_COMMENT', 'FILE_NOTICE', 'FILE_CONTRIBUTOR', 'FILE_ATTRIBUTION_TEXT', 'LICENSE_ID', 'LICENSE_TEXT', 'LICENSE_NAME', 'LICENSE_CROSS_REF', 'LICENSE_COMMENT', 'SNIPPET_SPDX_ID', 'SNIPPET_NAME', 'SNIPPET_COMMENT', 'SNIPPET_COPYRIGHT_TEXT', 'SNIPPET_LICENSE_COMMENT', 'SNIPPET_FILE_SPDXID', 'SNIPPET_LICENSE_CONCLUDED', 'SNIPPET_LICENSE_INFO', 'SNIPPET_ATTRIBUTION_TEXT', 'SNIPPET_BYTE_RANGE', 'SNIPPET_LINE_RANGE', 'NO_ASSERTION', 'NONE']
lexer
@TOKEN(':\\s*<text>')
def t_text(self, t):
120    @TOKEN(r":\s*<text>")
121    def t_text(self, t):
122        t.lexer.text_start = t.lexer.lexpos - len("<text>")
123        t.lexer.begin("text")
@TOKEN('</text>\\s*')
def t_text_end(self, t):
125    @TOKEN(r"</text>\s*")
126    def t_text_end(self, t):
127        t.type = "TEXT"
128        t.value = t.lexer.lexdata[t.lexer.text_start : t.lexer.lexpos]
129        t.lexer.lineno += t.value.count("\n")
130        t.value = t.value.strip()
131        t.lexer.begin("INITIAL")
132        return t
@TOKEN('.|\\n')
def t_text_any(self, t):
134    @TOKEN(r".|\n")
135    def t_text_any(self, t):
136        pass
def t_text_error(self, t):
138    def t_text_error(self, t):
139        print("Lexer error in text state")
@TOKEN(':\\s*(ADLER32|BLAKE2b-256|BLAKE2b-384|BLAKE2b-512|BLAKE3|MD2|MD4|MD5|MD6|SHA1|SHA224|SHA256|SHA384|SHA512|SHA3-256|SHA3-384|SHA3-512):\\s*([a-f0-9]*)')
def t_CHECKSUM(self, t):
141    @TOKEN(
142        r":\s*(ADLER32|BLAKE2b-256|BLAKE2b-384|BLAKE2b-512|BLAKE3|MD2|MD4|MD5|MD6|SHA1|SHA224|SHA256|SHA384|SHA512|"
143        r"SHA3-256|SHA3-384|SHA3-512):\s*([a-f0-9]*)"
144    )
145    def t_CHECKSUM(self, t):
146        t.value = t.value[1:].strip()
147        return t
@TOKEN(':\\s*Tool:.+')
def t_TOOL_VALUE(self, t):
149    @TOKEN(r":\s*Tool:.+")
150    def t_TOOL_VALUE(self, t):
151        t.value = t.value[1:].strip()
152        return t
@TOKEN(':\\s*Organization:.+')
def t_ORGANIZATION_VALUE(self, t):
154    @TOKEN(r":\s*Organization:.+")
155    def t_ORGANIZATION_VALUE(self, t):
156        t.value = t.value[1:].strip()
157        return t
@TOKEN(':\\s*Person:.+')
def t_PERSON_VALUE(self, t):
159    @TOKEN(r":\s*Person:.+")
160    def t_PERSON_VALUE(self, t):
161        t.value = t.value[1:].strip()
162        return t
@TOKEN(':\\s*\\d\\d\\d\\d-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\dZ')
def t_ISO8601_DATE(self, t):
164    @TOKEN(r":\s*\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\dZ")
165    def t_ISO8601_DATE(self, t):
166        t.value = t.value[1:].strip()
167        return t
@TOKEN('[a-zA-Z]+')
def t_KEYWORD_AS_TAG(self, t):
169    @TOKEN(r"[a-zA-Z]+")
170    def t_KEYWORD_AS_TAG(self, t):
171        t.type = self.reserved.get(t.value, "UNKNOWN_TAG")
172        t.value = t.value.strip()
173        return t
@TOKEN(':.+')
def t_LINE_OR_KEYWORD_VALUE(self, t):
175    @TOKEN(r":.+")
176    def t_LINE_OR_KEYWORD_VALUE(self, t):
177        t.value = t.value[1:].strip()
178        if t.value in self.reserved.keys():
179            t.type = self.reserved[t.value]
180        else:
181            t.type = "LINE"
182        return t
@TOKEN('\\#.*')
def t_comment(self, t):
184    @TOKEN(r"\#.*")
185    def t_comment(self, t):
186        pass
@TOKEN('\\n+')
def t_newline(self, t):
188    @TOKEN(r"\n+")
189    def t_newline(self, t):
190        t.lexer.lineno += len(t.value)
@TOKEN('[ \\t]+')
def t_whitespace(self, t):
192    @TOKEN(r"[ \t]+")
193    def t_whitespace(self, t):
194        pass
def build(self, **kwargs):
196    def build(self, **kwargs):
197        self.lexer = lex.lex(module=self, **kwargs)
def token(self):
199    def token(self):
200        return self.lexer.token()
def input(self, data):
202    def input(self, data):
203        self.lexer.input(data)
def t_error(self, t):
205    def t_error(self, t):
206        t.lexer.skip(1)
207        t.value = "Lexer error"
208        return t