comparison modules/javafx.web/src/main/native/Source/ThirdParty/icu/source/i18n/uspoof_conf.cpp @ 11038:20a8447c71c6

8207159: Update ICU to version 62.1 Reviewed-by: mbilla, kcr, ghb
author arajkumar
date Fri, 24 Aug 2018 15:06:40 +0530
parents fee4ef5c87df
children
comparison
equal deleted inserted replaced
0:6d67dce24fe0 1:0b95203af7e2
1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
1 /* 3 /*
2 ****************************************************************************** 4 ******************************************************************************
3 * 5 *
4 * Copyright (C) 2008-2013, International Business Machines 6 * Copyright (C) 2008-2015, International Business Machines
5 * Corporation and others. All Rights Reserved. 7 * Corporation and others. All Rights Reserved.
6 * 8 *
7 ****************************************************************************** 9 ******************************************************************************
8 * file name: uspoof_conf.cpp 10 * file name: uspoof_conf.cpp
9 * encoding: US-ASCII 11 * encoding: UTF-8
10 * tab size: 8 (not used) 12 * tab size: 8 (not used)
11 * indentation:4 13 * indentation:4
12 * 14 *
13 * created on: 2009Jan05 (refactoring earlier files) 15 * created on: 2009Jan05 (refactoring earlier files)
14 * created by: Andy Heninger 16 * created by: Andy Heninger
41 // the Unicode data file confusables.txt, into the binary 43 // the Unicode data file confusables.txt, into the binary
42 // structures used by the confusable detector. 44 // structures used by the confusable detector.
43 // 45 //
44 // The binary structures are described in uspoof_impl.h 46 // The binary structures are described in uspoof_impl.h
45 // 47 //
46 // 1. parse the data, building 4 hash tables, one each for the SL, SA, ML and MA 48 // 1. Parse the data, making a hash table mapping from a UChar32 to a String.
47 // tables. Each maps from a UChar32 to a String.
48 // 49 //
49 // 2. Sort all of the strings encountered by length, since they will need to 50 // 2. Sort all of the strings encountered by length, since they will need to
50 // be stored in that order in the final string table. 51 // be stored in that order in the final string table.
52 // TODO: Sorting these strings by length is no longer needed since the removal of
53 // the string lengths table. This logic can be removed to save processing time
54 // when building confusables data.
51 // 55 //
52 // 3. Build a list of keys (UChar32s) from the four mapping tables. Sort the 56 // 3. Build a list of keys (UChar32s) from the four mapping tables. Sort the
53 // list because that will be the ordering of our runtime table. 57 // list because that will be the ordering of our runtime table.
54 // 58 //
55 // 4. Generate the run time string table. This is generated before the key & value 59 // 4. Generate the run time string table. This is generated before the key & value
59 // at the same time 63 // at the same time
60 // 64 //
61 65
62 SPUString::SPUString(UnicodeString *s) { 66 SPUString::SPUString(UnicodeString *s) {
63 fStr = s; 67 fStr = s;
64 fStrTableIndex = 0; 68 fCharOrStrTableIndex = 0;
65 } 69 }
66 70
67 71
68 SPUString::~SPUString() { 72 SPUString::~SPUString() {
69 delete fStr; 73 delete fStr;
70 } 74 }
71 75
72 76
73 SPUStringPool::SPUStringPool(UErrorCode &status) : fVec(NULL), fHash(NULL) { 77 SPUStringPool::SPUStringPool(UErrorCode &status) : fVec(NULL), fHash(NULL) {
74 fVec = new UVector(status); 78 fVec = new UVector(status);
79 if (fVec == NULL) {
80 status = U_MEMORY_ALLOCATION_ERROR;
81 return;
82 }
75 fHash = uhash_open(uhash_hashUnicodeString, // key hash function 83 fHash = uhash_open(uhash_hashUnicodeString, // key hash function
76 uhash_compareUnicodeString, // Key Comparator 84 uhash_compareUnicodeString, // Key Comparator
77 NULL, // Value Comparator 85 NULL, // Value Comparator
78 &status); 86 &status);
79 } 87 }
130 SPUString *hashedString = static_cast<SPUString *>(uhash_get(fHash, src)); 138 SPUString *hashedString = static_cast<SPUString *>(uhash_get(fHash, src));
131 if (hashedString != NULL) { 139 if (hashedString != NULL) {
132 delete src; 140 delete src;
133 } else { 141 } else {
134 hashedString = new SPUString(src); 142 hashedString = new SPUString(src);
143 if (hashedString == NULL) {
144 status = U_MEMORY_ALLOCATION_ERROR;
145 return NULL;
146 }
135 uhash_put(fHash, src, hashedString, &status); 147 uhash_put(fHash, src, hashedString, &status);
136 fVec->addElement(hashedString, status); 148 fVec->addElement(hashedString, status);
137 } 149 }
138 return hashedString; 150 return hashedString;
139 } 151 }
141 153
142 154
143 ConfusabledataBuilder::ConfusabledataBuilder(SpoofImpl *spImpl, UErrorCode &status) : 155 ConfusabledataBuilder::ConfusabledataBuilder(SpoofImpl *spImpl, UErrorCode &status) :
144 fSpoofImpl(spImpl), 156 fSpoofImpl(spImpl),
145 fInput(NULL), 157 fInput(NULL),
146 fSLTable(NULL), 158 fTable(NULL),
147 fSATable(NULL),
148 fMLTable(NULL),
149 fMATable(NULL),
150 fKeySet(NULL), 159 fKeySet(NULL),
151 fKeyVec(NULL), 160 fKeyVec(NULL),
152 fValueVec(NULL), 161 fValueVec(NULL),
153 fStringTable(NULL), 162 fStringTable(NULL),
154 fStringLengthsTable(NULL),
155 stringPool(NULL), 163 stringPool(NULL),
156 fParseLine(NULL), 164 fParseLine(NULL),
157 fParseHexNum(NULL), 165 fParseHexNum(NULL),
158 fLineNum(0) 166 fLineNum(0)
159 { 167 {
160 if (U_FAILURE(status)) { 168 if (U_FAILURE(status)) {
161 return; 169 return;
162 } 170 }
163 fSLTable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); 171
164 fSATable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); 172 fTable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status);
165 fMLTable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); 173
166 fMATable = uhash_open(uhash_hashLong, uhash_compareLong, NULL, &status); 174 fKeySet = new UnicodeSet();
167 fKeySet = new UnicodeSet(); 175 if (fKeySet == NULL) {
168 fKeyVec = new UVector(status); 176 status = U_MEMORY_ALLOCATION_ERROR;
169 fValueVec = new UVector(status); 177 return;
178 }
179
180 fKeyVec = new UVector(status);
181 if (fKeyVec == NULL) {
182 status = U_MEMORY_ALLOCATION_ERROR;
183 return;
184 }
185
186 fValueVec = new UVector(status);
187 if (fValueVec == NULL) {
188 status = U_MEMORY_ALLOCATION_ERROR;
189 return;
190 }
191
170 stringPool = new SPUStringPool(status); 192 stringPool = new SPUStringPool(status);
193 if (stringPool == NULL) {
194 status = U_MEMORY_ALLOCATION_ERROR;
195 return;
196 }
171 } 197 }
172 198
173 199
174 ConfusabledataBuilder::~ConfusabledataBuilder() { 200 ConfusabledataBuilder::~ConfusabledataBuilder() {
175 uprv_free(fInput); 201 uprv_free(fInput);
176 uregex_close(fParseLine); 202 uregex_close(fParseLine);
177 uregex_close(fParseHexNum); 203 uregex_close(fParseHexNum);
178 uhash_close(fSLTable); 204 uhash_close(fTable);
179 uhash_close(fSATable);
180 uhash_close(fMLTable);
181 uhash_close(fMATable);
182 delete fKeySet; 205 delete fKeySet;
183 delete fKeyVec; 206 delete fKeyVec;
184 delete fStringTable; 207 delete fStringTable;
185 delete fStringLengthsTable;
186 delete fValueVec; 208 delete fValueVec;
187 delete stringPool; 209 delete stringPool;
188 } 210 }
189 211
190 212
226 248
227 // Regular Expression to parse a line from Confusables.txt. The expression will match 249 // Regular Expression to parse a line from Confusables.txt. The expression will match
228 // any line. What was matched is determined by examining which capture groups have a match. 250 // any line. What was matched is determined by examining which capture groups have a match.
229 // Capture Group 1: the source char 251 // Capture Group 1: the source char
230 // Capture Group 2: the replacement chars 252 // Capture Group 2: the replacement chars
231 // Capture Group 3-6 the table type, SL, SA, ML, or MA 253 // Capture Group 3-6 the table type, SL, SA, ML, or MA (deprecated)
232 // Capture Group 7: A blank or comment only line. 254 // Capture Group 7: A blank or comment only line.
233 // Capture Group 8: A syntactically invalid line. Anything that didn't match before. 255 // Capture Group 8: A syntactically invalid line. Anything that didn't match before.
234 // Example Line from the confusables.txt source file: 256 // Example Line from the confusables.txt source file:
235 // "1D702 ; 006E 0329 ; SL # MATHEMATICAL ITALIC SMALL ETA ... " 257 // "1D702 ; 006E 0329 ; SL # MATHEMATICAL ITALIC SMALL ETA ... "
236 UnicodeString pattern( 258 UnicodeString pattern(
292 314
293 // Put the map (value) string into the string pool 315 // Put the map (value) string into the string pool
294 // This a little like a Java intern() - any duplicates will be eliminated. 316 // This a little like a Java intern() - any duplicates will be eliminated.
295 SPUString *smapString = stringPool->addString(mapString, status); 317 SPUString *smapString = stringPool->addString(mapString, status);
296 318
297 // Add the UChar32 -> string mapping to the appropriate table. 319 // Add the UChar32 -> string mapping to the table.
298 UHashtable *table = uregex_start(fParseLine, 3, &status) >= 0 ? fSLTable : 320 // For Unicode 8, the SL, SA and ML tables have been discontinued.
299 uregex_start(fParseLine, 4, &status) >= 0 ? fSATable : 321 // All input data from confusables.txt is tagged MA.
300 uregex_start(fParseLine, 5, &status) >= 0 ? fMLTable : 322 uhash_iput(fTable, keyChar, smapString, &status);
301 uregex_start(fParseLine, 6, &status) >= 0 ? fMATable : 323 if (U_FAILURE(status)) { return; }
302 NULL;
303 U_ASSERT(table != NULL);
304 uhash_iput(table, keyChar, smapString, &status);
305 fKeySet->add(keyChar); 324 fKeySet->add(keyChar);
306 if (U_FAILURE(status)) {
307 return;
308 }
309 } 325 }
310 326
311 // Input data is now all parsed and collected. 327 // Input data is now all parsed and collected.
312 // Now create the run-time binary form of the data. 328 // Now create the run-time binary form of the data.
313 // 329 //
316 // into the actual raw-bytes data storage. 332 // into the actual raw-bytes data storage.
317 333
318 // Build up the string array, and record the index of each string therein 334 // Build up the string array, and record the index of each string therein
319 // in the (build time only) string pool. 335 // in the (build time only) string pool.
320 // Strings of length one are not entered into the strings array. 336 // Strings of length one are not entered into the strings array.
321 // At the same time, build up the string lengths table, which records the
322 // position in the string table of the first string of each length >= 4.
323 // (Strings in the table are sorted by length) 337 // (Strings in the table are sorted by length)
324 stringPool->sort(status); 338 stringPool->sort(status);
325 fStringTable = new UnicodeString(); 339 fStringTable = new UnicodeString();
326 fStringLengthsTable = new UVector(status);
327 int32_t previousStringLength = 0;
328 int32_t previousStringIndex = 0;
329 int32_t poolSize = stringPool->size(); 340 int32_t poolSize = stringPool->size();
330 int32_t i; 341 int32_t i;
331 for (i=0; i<poolSize; i++) { 342 for (i=0; i<poolSize; i++) {
332 SPUString *s = stringPool->getByIndex(i); 343 SPUString *s = stringPool->getByIndex(i);
333 int32_t strLen = s->fStr->length(); 344 int32_t strLen = s->fStr->length();
334 int32_t strIndex = fStringTable->length(); 345 int32_t strIndex = fStringTable->length();
335 U_ASSERT(strLen >= previousStringLength);
336 if (strLen == 1) { 346 if (strLen == 1) {
337 // strings of length one do not get an entry in the string table. 347 // strings of length one do not get an entry in the string table.
338 // Keep the single string character itself here, which is the same 348 // Keep the single string character itself here, which is the same
339 // convention that is used in the final run-time string table index. 349 // convention that is used in the final run-time string table index.
340 s->fStrTableIndex = s->fStr->charAt(0); 350 s->fCharOrStrTableIndex = s->fStr->charAt(0);
341 } else { 351 } else {
342 if ((strLen > previousStringLength) && (previousStringLength >= 4)) { 352 s->fCharOrStrTableIndex = strIndex;
343 fStringLengthsTable->addElement(previousStringIndex, status);
344 fStringLengthsTable->addElement(previousStringLength, status);
345 }
346 s->fStrTableIndex = strIndex;
347 fStringTable->append(*(s->fStr)); 353 fStringTable->append(*(s->fStr));
348 } 354 }
349 previousStringLength = strLen;
350 previousStringIndex = strIndex;
351 }
352 // Make the final entry to the string lengths table.
353 // (it holds an entry for the _last_ string of each length, so adding the
354 // final one doesn't happen in the main loop because no longer string was encountered.)
355 if (previousStringLength >= 4) {
356 fStringLengthsTable->addElement(previousStringIndex, status);
357 fStringLengthsTable->addElement(previousStringLength, status);
358 } 355 }
359 356
360 // Construct the compile-time Key and Value tables 357 // Construct the compile-time Key and Value tables
361 // 358 //
362 // For each key code point, check which mapping tables it applies to, 359 // For each key code point, check which mapping tables it applies to,
371 for (int32_t range=0; range<fKeySet->getRangeCount(); range++) { 368 for (int32_t range=0; range<fKeySet->getRangeCount(); range++) {
372 // It is an oddity of the UnicodeSet API that simply enumerating the contained 369 // It is an oddity of the UnicodeSet API that simply enumerating the contained
373 // code points requires a nested loop. 370 // code points requires a nested loop.
374 for (UChar32 keyChar=fKeySet->getRangeStart(range); 371 for (UChar32 keyChar=fKeySet->getRangeStart(range);
375 keyChar <= fKeySet->getRangeEnd(range); keyChar++) { 372 keyChar <= fKeySet->getRangeEnd(range); keyChar++) {
376 addKeyEntry(keyChar, fSLTable, USPOOF_SL_TABLE_FLAG, status); 373 SPUString *targetMapping = static_cast<SPUString *>(uhash_iget(fTable, keyChar));
377 addKeyEntry(keyChar, fSATable, USPOOF_SA_TABLE_FLAG, status); 374 U_ASSERT(targetMapping != NULL);
378 addKeyEntry(keyChar, fMLTable, USPOOF_ML_TABLE_FLAG, status); 375
379 addKeyEntry(keyChar, fMATable, USPOOF_MA_TABLE_FLAG, status); 376 // Set an error code if trying to consume a long string. Otherwise,
377 // codePointAndLengthToKey will abort on a U_ASSERT.
378 if (targetMapping->fStr->length() > 256) {
379 status = U_ILLEGAL_ARGUMENT_ERROR;
380 return;
381 }
382
383 int32_t key = ConfusableDataUtils::codePointAndLengthToKey(keyChar,
384 targetMapping->fStr->length());
385 int32_t value = targetMapping->fCharOrStrTableIndex;
386
387 fKeyVec->addElement(key, status);
388 fValueVec->addElement(value, status);
380 } 389 }
381 } 390 }
382 391
383 // Put the assembled data into the flat runtime array 392 // Put the assembled data into the flat runtime array
384 outputData(status); 393 outputData(status);
410 static_cast<int32_t *>(fSpoofImpl->fSpoofData->reserveSpace(numKeys*sizeof(int32_t), status)); 419 static_cast<int32_t *>(fSpoofImpl->fSpoofData->reserveSpace(numKeys*sizeof(int32_t), status));
411 if (U_FAILURE(status)) { 420 if (U_FAILURE(status)) {
412 return; 421 return;
413 } 422 }
414 int i; 423 int i;
415 int32_t previousKey = 0; 424 UChar32 previousCodePoint = 0;
416 for (i=0; i<numKeys; i++) { 425 for (i=0; i<numKeys; i++) {
417 int32_t key = fKeyVec->elementAti(i); 426 int32_t key = fKeyVec->elementAti(i);
418 (void)previousKey; // Suppress unused variable warning on gcc. 427 UChar32 codePoint = ConfusableDataUtils::keyToCodePoint(key);
419 U_ASSERT((key & 0x00ffffff) >= (previousKey & 0x00ffffff)); 428 (void)previousCodePoint; // Suppress unused variable warning.
420 U_ASSERT((key & 0xff000000) != 0); 429 // strictly greater because there can be only one entry per code point
430 U_ASSERT(codePoint > previousCodePoint);
421 keys[i] = key; 431 keys[i] = key;
422 previousKey = key; 432 previousCodePoint = codePoint;
423 } 433 }
424 SpoofDataHeader *rawData = fSpoofImpl->fSpoofData->fRawData; 434 SpoofDataHeader *rawData = fSpoofImpl->fSpoofData->fRawData;
425 rawData->fCFUKeys = (int32_t)((char *)keys - (char *)rawData); 435 rawData->fCFUKeys = (int32_t)((char *)keys - (char *)rawData);
426 rawData->fCFUKeysSize = numKeys; 436 rawData->fCFUKeysSize = numKeys;
427 fSpoofImpl->fSpoofData->fCFUKeys = keys; 437 fSpoofImpl->fSpoofData->fCFUKeys = keys;
459 rawData = fSpoofImpl->fSpoofData->fRawData; 469 rawData = fSpoofImpl->fSpoofData->fRawData;
460 U_ASSERT(rawData->fCFUStringTable == 0); 470 U_ASSERT(rawData->fCFUStringTable == 0);
461 rawData->fCFUStringTable = (int32_t)((char *)strings - (char *)rawData); 471 rawData->fCFUStringTable = (int32_t)((char *)strings - (char *)rawData);
462 rawData->fCFUStringTableLen = stringsLength; 472 rawData->fCFUStringTableLen = stringsLength;
463 fSpoofImpl->fSpoofData->fCFUStrings = strings; 473 fSpoofImpl->fSpoofData->fCFUStrings = strings;
464
465 // The String Lengths Table
466 // While copying into the runtime array do some sanity checks on the values
467 // Each complete entry contains two fields, an index and an offset.
468 // Lengths should increase with each entry.
469 // Offsets should be less than the size of the string table.
470 int32_t lengthTableLength = fStringLengthsTable->size();
471 uint16_t *stringLengths =
472 static_cast<uint16_t *>(fSpoofImpl->fSpoofData->reserveSpace(lengthTableLength*sizeof(uint16_t), status));
473 if (U_FAILURE(status)) {
474 return;
475 }
476 int32_t destIndex = 0;
477 uint32_t previousLength = 0;
478 for (i=0; i<lengthTableLength; i+=2) {
479 uint32_t offset = static_cast<uint32_t>(fStringLengthsTable->elementAti(i));
480 uint32_t length = static_cast<uint32_t>(fStringLengthsTable->elementAti(i+1));
481 U_ASSERT(offset < stringsLength);
482 U_ASSERT(length < 40);
483 (void)previousLength; // Suppress unused variable warning on gcc.
484 U_ASSERT(length > previousLength);
485 stringLengths[destIndex++] = static_cast<uint16_t>(offset);
486 stringLengths[destIndex++] = static_cast<uint16_t>(length);
487 previousLength = length;
488 }
489 rawData = fSpoofImpl->fSpoofData->fRawData;
490 rawData->fCFUStringLengths = (int32_t)((char *)stringLengths - (char *)rawData);
491 // Note: StringLengthsSize in the raw data is the number of complete entries,
492 // each consisting of a pair of 16 bit values, hence the divide by 2.
493 rawData->fCFUStringLengthsSize = lengthTableLength / 2;
494 fSpoofImpl->fSpoofData->fCFUStringLengths =
495 reinterpret_cast<SpoofStringLengthsElement *>(stringLengths);
496 }
497
498
499
500 // addKeyEntry Construction of the confusable Key and Mapping Values tables.
501 // This is an intermediate point in the building process.
502 // We already have the mappings in the hash tables fSLTable, etc.
503 // This function builds corresponding run-time style table entries into
504 // fKeyVec and fValueVec
505
506 void ConfusabledataBuilder::addKeyEntry(
507 UChar32 keyChar, // The key character
508 UHashtable *table, // The table, one of SATable, MATable, etc.
509 int32_t tableFlag, // One of USPOOF_SA_TABLE_FLAG, etc.
510 UErrorCode &status) {
511
512 SPUString *targetMapping = static_cast<SPUString *>(uhash_iget(table, keyChar));
513 if (targetMapping == NULL) {
514 // No mapping for this key character.
515 // (This function is called for all four tables for each key char that
516 // is seen anywhere, so this no entry cases are very much expected.)
517 return;
518 }
519
520 // Check whether there is already an entry with the correct mapping.
521 // If so, simply set the flag in the keyTable saying that the existing entry
522 // applies to the table that we're doing now.
523
524 UBool keyHasMultipleValues = FALSE;
525 int32_t i;
526 for (i=fKeyVec->size()-1; i>=0 ; i--) {
527 int32_t key = fKeyVec->elementAti(i);
528 if ((key & 0x0ffffff) != keyChar) {
529 // We have now checked all existing key entries for this key char (if any)
530 // without finding one with the same mapping.
531 break;
532 }
533 UnicodeString mapping = getMapping(i);
534 if (mapping == *(targetMapping->fStr)) {
535 // The run time entry we are currently testing has the correct mapping.
536 // Set the flag in it indicating that it applies to the new table also.
537 key |= tableFlag;
538 fKeyVec->setElementAt(key, i);
539 return;
540 }
541 keyHasMultipleValues = TRUE;
542 }
543
544 // Need to add a new entry to the binary data being built for this mapping.
545 // Includes adding entries to both the key table and the parallel values table.
546
547 int32_t newKey = keyChar | tableFlag;
548 if (keyHasMultipleValues) {
549 newKey |= USPOOF_KEY_MULTIPLE_VALUES;
550 }
551 int32_t adjustedMappingLength = targetMapping->fStr->length() - 1;
552 if (adjustedMappingLength>3) {
553 adjustedMappingLength = 3;
554 }
555 newKey |= adjustedMappingLength << USPOOF_KEY_LENGTH_SHIFT;
556
557 int32_t newData = targetMapping->fStrTableIndex;
558
559 fKeyVec->addElement(newKey, status);
560 fValueVec->addElement(newData, status);
561
562 // If the preceding key entry is for the same key character (but with a different mapping)
563 // set the multiple-values flag on it.
564 if (keyHasMultipleValues) {
565 int32_t previousKeyIndex = fKeyVec->size() - 2;
566 int32_t previousKey = fKeyVec->elementAti(previousKeyIndex);
567 previousKey |= USPOOF_KEY_MULTIPLE_VALUES;
568 fKeyVec->setElementAt(previousKey, previousKeyIndex);
569 }
570 }
571
572
573
574 UnicodeString ConfusabledataBuilder::getMapping(int32_t index) {
575 int32_t key = fKeyVec->elementAti(index);
576 int32_t value = fValueVec->elementAti(index);
577 int32_t length = USPOOF_KEY_LENGTH_FIELD(key);
578 int32_t lastIndexWithLen;
579 switch (length) {
580 case 0:
581 return UnicodeString(static_cast<UChar>(value));
582 case 1:
583 case 2:
584 return UnicodeString(*fStringTable, value, length+1);
585 case 3:
586 length = 0;
587 int32_t i;
588 for (i=0; i<fStringLengthsTable->size(); i+=2) {
589 lastIndexWithLen = fStringLengthsTable->elementAti(i);
590 if (value <= lastIndexWithLen) {
591 length = fStringLengthsTable->elementAti(i+1);
592 break;
593 }
594 }
595 U_ASSERT(length>=3);
596 return UnicodeString(*fStringTable, value, length);
597 default:
598 U_ASSERT(FALSE);
599 }
600 return UnicodeString();
601 } 474 }
602 475
603 #endif 476 #endif
604 #endif // !UCONFIG_NO_REGULAR_EXPRESSIONS 477 #endif // !UCONFIG_NO_REGULAR_EXPRESSIONS
605 478