Lines Matching refs:self
25 def __init__(self, filename: str, line_number: Union[int, str]) -> None:
27 super(ReadFileLineException, self).__init__(message)
28 self.filename = filename
29 self.line_number = line_number
51 def __init__(self, filename: str, binary: bool = False) -> None:
52 self.filename = filename
53 self.file = None #type: Optional[IO[str]]
54 self.line_number = 'entry' #type: Union[int, str]
55 self.generator = None #type: Optional[Iterable[Tuple[int, str]]]
56 self.binary = binary
57 def __enter__(self) -> 'read_file_lines':
58 self.file = open(self.filename, 'rb' if self.binary else 'r')
59 self.generator = enumerate(self.file)
60 return self
61 def __iter__(self) -> Iterator[str]:
62 assert self.generator is not None
63 for line_number, content in self.generator:
64 self.line_number = line_number
66 self.line_number = 'exit'
67 def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
68 if self.file is not None:
69 self.file.close()
71 raise ReadFileLineException(self.filename, self.line_number) \
84 `self.arguments_for` for arguments that are not of a kind that is
89 def __init__(self) -> None:
92 self.statuses = set() #type: Set[str]
93 self.lifetimes = set() #type: Set[str]
94 self.locations = set() #type: Set[str]
95 self.persistence_levels = set() #type: Set[str]
96 self.algorithms = set() #type: Set[str]
97 self.ecc_curves = set() #type: Set[str]
98 self.dh_groups = set() #type: Set[str]
99 self.key_types = set() #type: Set[str]
100 self.key_usage_flags = set() #type: Set[str]
101 self.hash_algorithms = set() #type: Set[str]
102 self.mac_algorithms = set() #type: Set[str]
103 self.ka_algorithms = set() #type: Set[str]
104 self.kdf_algorithms = set() #type: Set[str]
105 self.pake_algorithms = set() #type: Set[str]
106 self.aead_algorithms = set() #type: Set[str]
107 self.sign_algorithms = set() #type: Set[str]
109 self.argspecs = {} #type: Dict[str, List[str]]
111 self.arguments_for = {
121 self.include_intermediate = False
123 def is_internal_name(self, name: str) -> bool:
125 if not self.include_intermediate:
132 def gather_arguments(self) -> None:
137 self.arguments_for['hash_alg'] = sorted(self.hash_algorithms)
138 self.arguments_for['mac_alg'] = sorted(self.mac_algorithms)
139 self.arguments_for['ka_alg'] = sorted(self.ka_algorithms)
140 self.arguments_for['kdf_alg'] = sorted(self.kdf_algorithms)
141 self.arguments_for['aead_alg'] = sorted(self.aead_algorithms)
142 self.arguments_for['sign_alg'] = sorted(self.sign_algorithms)
143 self.arguments_for['curve'] = sorted(self.ecc_curves)
144 self.arguments_for['group'] = sorted(self.dh_groups)
145 self.arguments_for['persistence'] = sorted(self.persistence_levels)
146 self.arguments_for['location'] = sorted(self.locations)
147 self.arguments_for['lifetime'] = sorted(self.lifetimes)
163 def distribute_arguments(self, name: str) -> Iterator[str]:
172 if name not in self.argspecs:
175 argspec = self.argspecs[name]
179 argument_lists = [self.arguments_for[arg] for arg in argspec]
181 yield self._format_arguments(name, arguments)
188 yield self._format_arguments(name, arguments)
194 self, seen: Set[str], name: str
197 for result in self.distribute_arguments(name):
202 def generate_expressions(self, names: Iterable[str]) -> Iterator[str]:
216 self.distribute_arguments_without_duplicates(seen, name)
225 def __init__(self, include_intermediate: bool = False) -> None:
234 self.include_intermediate = include_intermediate
235 self.key_types_from_curve = {} #type: Dict[str, str]
236 self.key_types_from_group = {} #type: Dict[str, str]
237 self.algorithms_from_hash = {} #type: Dict[str, str]
260 def record_algorithm_subtype(self, name: str, expansion: str) -> None:
270 self.mac_algorithms.add(name)
272 self.kdf_algorithms.add(name)
274 self.hash_algorithms.add(name)
276 self.mac_algorithms.add(name)
278 self.aead_algorithms.add(name)
280 self.ka_algorithms.add(name)
282 self.kdf_algorithms.add(name)
293 def read_line(self, line):
299 m = re.match(self._define_directive_re, line)
305 self.argspecs[name] = [parameter]
306 if re.match(self._deprecated_definition_re, expansion):
311 if self.is_internal_name(name):
316 self.statuses.add(name)
318 self.key_types.add(name)
320 self.key_types_from_curve[name] = name[:13] + 'IS_' + name[13:]
322 self.key_types_from_group[name] = name[:13] + 'IS_' + name[13:]
324 self.ecc_curves.add(name)
326 self.dh_groups.add(name)
332 self.algorithms.add(name)
333 self.record_algorithm_subtype(name, expansion)
335 self.algorithms_from_hash[name] = self.algorithm_tester(name)
337 self.key_usage_flags.add(name)
344 def read_file(self, header_file):
346 m = re.search(self._continued_line_re, line)
350 m = re.search(self._continued_line_re, line)
351 line = re.sub(self._nonascii_re, rb'', line).decode('ascii')
352 self.read_line(line)
363 def __init__(self) -> None:
365 self.all_declared = set() #type: Set[str]
367 self.table_by_prefix = {
368 'ERROR': self.statuses,
369 'ALG': self.algorithms,
370 'ECC_CURVE': self.ecc_curves,
371 'DH_GROUP': self.dh_groups,
372 'KEY_LIFETIME': self.lifetimes,
373 'KEY_LOCATION': self.locations,
374 'KEY_PERSISTENCE': self.persistence_levels,
375 'KEY_TYPE': self.key_types,
376 'KEY_USAGE': self.key_usage_flags,
379 self.table_by_test_function = {
381 # self.algorithms.
382 'key_type': [self.key_types],
383 'block_cipher_key_type': [self.key_types],
384 'stream_cipher_key_type': [self.key_types],
385 'ecc_key_family': [self.ecc_curves],
386 'ecc_key_types': [self.ecc_curves],
387 'dh_key_family': [self.dh_groups],
388 'dh_key_types': [self.dh_groups],
389 'hash_algorithm': [self.hash_algorithms],
390 'mac_algorithm': [self.mac_algorithms],
392 'hmac_algorithm': [self.mac_algorithms, self.sign_algorithms],
393 'aead_algorithm': [self.aead_algorithms],
394 'key_derivation_algorithm': [self.kdf_algorithms],
395 'key_agreement_algorithm': [self.ka_algorithms],
396 'asymmetric_signature_algorithm': [self.sign_algorithms],
397 'asymmetric_signature_wildcard': [self.algorithms],
399 'pake_algorithm': [self.pake_algorithms],
401 'lifetime': [self.lifetimes],
411 self.arguments_for['mac_length'] += mac_lengths
412 self.arguments_for['min_mac_length'] += mac_lengths
421 self.arguments_for['tag_length'] += aead_lengths
422 self.arguments_for['min_tag_length'] += aead_lengths
424 def add_numerical_values(self) -> None:
427 self.algorithms.add('0xffffffff')
428 self.ecc_curves.add('0xff')
429 self.dh_groups.add('0xff')
430 self.key_types.add('0xffff')
431 self.key_usage_flags.add('0x80000000')
438 self.hash_algorithms.add('0x020000fe') # 0x020000ff is PSA_ALG_ANY_HASH
439 self.mac_algorithms.add('0x03007fff')
440 self.ka_algorithms.add('0x09fc0000')
441 self.kdf_algorithms.add('0x080000ff')
442 self.pake_algorithms.add('0x0a0000ff')
447 def get_names(self, type_word: str) -> Set[str]:
450 'status': self.statuses,
451 'algorithm': self.algorithms,
452 'ecc_curve': self.ecc_curves,
453 'dh_group': self.dh_groups,
454 'key_type': self.key_types,
455 'key_usage': self.key_usage_flags,
476 def parse_header_line(self, line: str) -> None:
478 m = re.match(self._header_line_re, line)
482 self.all_declared.add(name)
483 if re.search(self._excluded_name_re, name) or \
484 name in self._excluded_names or \
485 self.is_internal_name(name):
487 dest = self.table_by_prefix.get(m.group(2))
492 self.argspecs[name] = self._argument_split(m.group(3))
495 def parse_header(self, filename: str) -> None:
499 line = re.sub(self._nonascii_re, rb'', line).decode('ascii')
500 self.parse_header_line(line)
503 def generate_undeclared_names(self, expr: str) -> Iterable[str]:
504 for name in re.findall(self._macro_identifier_re, expr):
505 if name not in self.all_declared:
508 def accept_test_case_line(self, function: str, argument: str) -> bool:
510 undeclared = list(self.generate_undeclared_names(argument))
524 def add_test_case_line(self, function: str, argument: str) -> None:
528 sets.append(self.algorithms)
535 sets += self.table_by_test_function[function]
536 if self.accept_test_case_line(function, argument):
538 s.add(self.normalize_argument(argument))
544 def parse_test_cases(self, filename: str) -> None:
548 m = re.match(self._test_case_line_re, line)
550 self.add_test_case_line(m.group(1), m.group(2))