/android/import-contacts : revision 62

1

/*

2

* VCFImporter.java

3

*

4

5

*

6

* This file is part of the Import Contacts program (hereafter referred

7

* to as "this program"). For more information, see

7

* to as "this program"). For more information, see

8

* http://ed.am/dev/android/import-contacts

9

*

10

* This program is free software: you can redistribute it and/or modify

133

boolean in_vcard = false;

134

while( ( line = reader.readLine() ) != null )

135

{

136

if( !in_vcard )

137

{

136

if( !in_vcard ) {

138

137

// look for vcard beginning

139

if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {

138

if( line.matches( "^BEGIN:VCARD" ) ) {

140

139

in_vcard = true;

141

140

_vcard_count++;

142

141

}

143

// check for vMsg files

144

else if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VMSG.*" ) ) {

145

showError( getText( R.string.error_vcf_vmsgfile )

146

+ file.getName() );

147

}

148

142

}

149

else if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )

143

else if( line.matches( "^END:VCARD" ) )

150

144

in_vcard = false;

151

145

}

152

146

181

175

// import

182

176

importVCardFileContent( content, file.getName() );

183

177

}

184

catch( OutOfMemoryError e ) {

185

showError( R.string.error_outofmemory );

186

}

187

178

catch( FileNotFoundException e ) {

188

179

showError( getText( R.string.error_filenotfound ) +

189

180

file.getName() );

202

193

ContentLineIterator cli = new ContentLineIterator( content );

203

194

while( cli.hasNext() )

204

195

{

205

ContentLine content_line = cli.next();

196

ByteBuffer buffer = cli.next();

206

197

207

// get a US-ASCII version of the string, for processing

208

String line = content_line.getUsAsciiLine();

198

// get a US-ASCII version of the line for processing

199

String line;

200

try {

201

line = new String( buffer.array(), buffer.position(),

202

buffer.limit() - buffer.position(), "US-ASCII" );

203

}

204

catch( UnsupportedEncodingException e ) {

205

// we know US-ASCII is supported, so appease the compiler...

206

line = "";

207

}

209

208

210

209

if( vcard == null ) {

211

210

// look for vcard beginning

212

if( line.matches( "(?i)BEGIN[ \t]*:[ \t]*VCARD.*" ) ) {

211

if( line.matches( "^BEGIN:VCARD" ) ) {

213

212

setProgress( _progress++ );

214

213

vcard = new Vcard();

215

214

vcard_start_line = cli.getLineNumber();

217

216

}

218

217

else {

219

218

// look for vcard content or ending

220

if( line.matches( "(?i)END[ \t]*:[ \t]*VCARD.*" ) )

219

if( line.matches( "^END:VCARD" ) )

221

220

{

222

221

// finalise the vcard/contact

223

222

try {

260

259

{

261

260

// try giving the line to the vcard

262

261

try {

263

vcard.parseLine( content_line );

262

vcard.parseLine( buffer, line,

263

cli.doesNextLineLookFolded() );

264

}

265

catch( Vcard.ParseException e ) {

266

skipContact();

273

finish( ACTION_ABORT );

274

}

275

276

// Although we're continuing, we still need to abort

277

// this vCard. Further lines will be ignored until we

276

// although we're continuing, we still need to abort

277

// this vCard. Further lines will be ignored until we

278

// get to another BEGIN:VCARD line.

279

vcard = null;

280

}

281

catch( Vcard.SkipImportException e ) {

282

skipContact();

283

// Abort this vCard. Further lines will be ignored until

283

// abort this vCard. Further lines will be ignored until

284

// we get to another BEGIN:VCARD line.

285

vcard = null;

286

}

289

}

290

}

291

292

class ContentLine

293

{

294

private ByteBuffer _buffer;

295

private boolean _folded_next;

296

private String _line;

297

298

public ContentLine( ByteBuffer buffer, boolean folded_next )

299

{

300

_buffer = buffer;

301

_folded_next = folded_next;

302

_line = null;

303

}

304

305

public ByteBuffer getBuffer()

306

{

307

return _buffer;

308

}

309

310

public boolean doesNextLineLookFolded()

311

{

312

return _folded_next;

313

}

314

315

public String getUsAsciiLine()

316

{

317

// generated line and cache it

318

if( _line == null ) {

319

try {

320

_line = new String( _buffer.array(), _buffer.position(),

321

_buffer.limit() - _buffer.position(), "US-ASCII" );

322

}

323

catch( UnsupportedEncodingException e ) {

324

// we know US-ASCII *is* supported, so appease the

325

// compiler...

326

}

327

}

328

329

// return cached line

330

return _line;

331

}

332

}

333

334

class ContentLineIterator implements Iterator< ContentLine >

292

class ContentLineIterator implements Iterator< ByteBuffer >

335

293

{

336

294

protected byte[] _content = null;

337

295

protected int _pos = 0;

349

307

}

350

308

351

309

@Override

352

public ContentLine next()

310

public ByteBuffer next()

353

311

{

354

312

int initial_pos = _pos;

355

313

362

320

_pos > initial_pos )? _pos - 1 : _pos;

363

321

_pos++;

364

322

_line++;

365

return new ContentLine(

366

ByteBuffer.wrap( _content, initial_pos,

367

to - initial_pos ),

368

doesNextLineLookFolded() );

323

return ByteBuffer.wrap( _content, initial_pos,

324

to - initial_pos );

369

325

}

370

326

371

327

// we didn't find one, but were there bytes left?

373

329

int to = _pos;

374

330

_pos++;

375

331

_line++;

376

return new ContentLine(

377

ByteBuffer.wrap( _content, initial_pos,

378

to - initial_pos ),

379

doesNextLineLookFolded() );

332

return ByteBuffer.wrap( _content, initial_pos,

333

to - initial_pos );

380

334

}

381

335

382

336

// no bytes left

394

348

* onto the end of this one?

395

349

* @return

396

350

*/

397

private boolean doesNextLineLookFolded()

351

public boolean doesNextLineLookFolded()

398

352

{

399

353

return _pos > 0 && _pos < _content.length &&

400

_content[ _pos - 1 ] == '\n' &&

401

( _content[ _pos ] == ' ' || _content[ _pos ] == '\t' );

354

_content[ _pos - 1 ] == '\n' && _content[ _pos ] == ' ';

402

355

}

403

356

404

357

public int getLineNumber()

416

369

private final static int MULTILINE_NONE = 0;

417

370

private final static int MULTILINE_ENCODED = 1; // v2.1 quoted-printable

418

371

private final static int MULTILINE_ESCAPED = 2; // v2.1 \\CRLF

419

private final static int MULTILINE_FOLDED = 3; // MIME-DIR folding

372

private final static int MULTILINE_FOLDED = 3; // v3.0 folding

420

373

421

374

private String _version = null;

422

private Vector< ContentLine > _content_lines = null;

375

private Vector< ByteBuffer > _buffers = null;

423

376

private int _name_level = NAMELEVEL_NONE;

424

377

private int _parser_multiline_state = MULTILINE_NONE;

425

378

private String _parser_current_name_and_params = null;

468

421

@SuppressWarnings("serial")

469

422

protected class SkipImportException extends Exception { }

470

423

471

private String extractCollonPartFromLine( ContentLine content_line,

472

boolean former )

424

private String extractCollonPartFromLine( ByteBuffer buffer,

425

String line, boolean former )

473

426

{

427

String ret = null;

428

429

// get a US-ASCII version of the line for processing, unless we were

430

// supplied with one

431

if( line == null ) {

432

try {

433

line = new String( buffer.array(), buffer.position(),

434

buffer.limit() - buffer.position(), "US-ASCII" );

435

}

436

catch( UnsupportedEncodingException e ) {

437

// we know US-ASCII is supported, so appease the compiler...

438

line = "";

439

}

440

}

441

474

442

// split line into name and value parts and check to make sure we

475

443

// only got 2 parts and that the first part is not zero in length

476

String[] parts = content_line.getUsAsciiLine().split( ":", 2 );

444

String[] parts = line.split( ":", 2 );

477

445

if( parts.length == 2 && parts[ 0 ].length() > 0 )

478

return parts[ former? 0 : 1 ].trim();

479

480

return null;

481

}

482

483

private String extractNameAndParamsFromLine( ContentLine content_line )

484

{

485

return extractCollonPartFromLine( content_line, true );

486

}

487

488

private String extractValueFromLine( ContentLine content_line )

489

{

490

return extractCollonPartFromLine( content_line, false );

491

}

492

493

public void parseLine( ContentLine content_line )

446

ret = parts[ former? 0 : 1 ];

447

448

return ret;

449

}

450

451

private String extractNameAndParamsFromLine( ByteBuffer buffer,

452

String line )

453

{

454

return extractCollonPartFromLine( buffer, line, true );

455

}

456

457

private String extractValueFromLine( ByteBuffer buffer, String line )

458

{

459

return extractCollonPartFromLine( buffer, line, false );

460

}

461

462

public void parseLine( ByteBuffer buffer, String line,

463

boolean next_line_looks_folded )

494

464

throws ParseException, SkipImportException,

495

465

AbortImportException

496

466

{

499

469

{

500

470

// tentatively get name and params from line

501

471

String name_and_params =

502

extractNameAndParamsFromLine( content_line );

472

extractNameAndParamsFromLine( buffer, line );

503

473

504

474

// is it a version line?

505

475

if( name_and_params != null &&

506

name_and_params.equalsIgnoreCase( "VERSION" ) )

476

name_and_params.equals( "VERSION" ) )

507

477

{

508

478

// yes, get it!

509

String value = extractValueFromLine( content_line );

510

if( value == null || (

511

!value.equals( "2.1" ) && !value.equals( "3.0" ) ) )

512

{

479

String value = extractValueFromLine( buffer, line );

480

if( !value.equals( "2.1" ) && !value.equals( "3.0" ) )

513

481

throw new ParseException( R.string.error_vcf_version );

514

}

515

482

_version = value;

516

483

517

484

// parse any buffers we've been accumulating while we waited

518

485

// for a version

519

if( _content_lines != null )

520

for( int i = 0; i < _content_lines.size(); i++ )

521

parseLine( _content_lines.get( i ) );

522

_content_lines = null;

486

if( _buffers != null )

487

for( int i = 0; i < _buffers.size(); i++ )

488

parseLine( _buffers.get( i ), null,

489

i + 1 < _buffers.size() &&

490

_buffers.get( i + 1 ).hasRemaining() &&

491

_buffers.get( i + 1 ).get(

492

_buffers.get( i + 1 ).position() ) == ' ' );

493

_buffers = null;

523

494

}

524

495

else

525

496

{

526

497

// no, so stash this line till we get a version

527

if( _content_lines == null )

528

_content_lines = new Vector< ContentLine >();

529

_content_lines.add( content_line );

498

if( _buffers == null )

499

_buffers = new Vector< ByteBuffer >();

500

_buffers.add( buffer );

530

501

}

531

502

}

532

503

else

533

504

{

534

505

// name and params and the position in the buffer where the

535

// "value" part of the line starts

506

// "value" part of the line start

536

507

String name_and_params;

537

508

int pos;

538

509

544

515

545

516

// skip some initial line characters, depending on the type

546

517

// of multi-line we're handling

547

pos = content_line.getBuffer().position();

518

pos = buffer.position();

548

519

switch( _parser_multiline_state )

549

520

{

550

521

case MULTILINE_FOLDED:

551

522

pos++;

552

523

break;

553

524

case MULTILINE_ENCODED:

554

while( pos < content_line.getBuffer().limit() && (

555

content_line.getBuffer().get( pos ) == ' ' ||

556

content_line.getBuffer().get( pos ) == '\t' ) )

525

while( pos < buffer.limit() && (

526

buffer.get( pos ) == ' ' ||

527

buffer.get( pos ) == '\t' ) )

557

528

{

558

529

pos++;

559

530

}

568

539

}

569

540

else

570

541

{

571

// skip empty lines

572

if( content_line.getUsAsciiLine().trim().length() == 0 )

573

return;

574

575

542

// get name and params from line, and since we're not

576

543

// parsing a subsequent line in a multi-line, this should

577

544

// not fail, or it's an error

578

545

name_and_params =

579

extractNameAndParamsFromLine( content_line );

546

extractNameAndParamsFromLine( buffer, line );

580

547

if( name_and_params == null )

581

548

throw new ParseException(

582

549

R.string.error_vcf_malformed );

583

550

584

551

// calculate how many chars to skip from beginning of line

585

552

// so we skip the property "name:" part

586

pos = content_line.getBuffer().position() +

587

name_and_params.length() + 1;

553

pos = buffer.position() + name_and_params.length() + 1;

588

554

589

555

// reset the saved multi-line state

590

556

_parser_current_name_and_params = name_and_params;

593

559

594

560

// get value from buffer, as raw bytes

595

561

ByteBuffer value;

596

value = ByteBuffer.wrap( content_line.getBuffer().array(), pos,

597

content_line.getBuffer().limit() - pos );

562

value = ByteBuffer.wrap( buffer.array(), pos,

563

buffer.limit() - pos );

598

564

599

565

// get parameter parts

600

566

String[] name_param_parts = name_and_params.split( ";", -1 );

607

573

"FN", "ORG", "TITLE", "TEL", "EMAIL", "ADR", "LABEL" }

608

574

) );

609

575

boolean is_interesting_field =

610

interesting_fields.contains(

611

name_param_parts[ 0 ].toUpperCase( Locale.US ) );

576

interesting_fields.contains( name_param_parts[ 0 ] );

612

577

613

578

// parse encoding parameter

614

579

String encoding = checkParam( name_param_parts, "ENCODING" );

615

580

if( encoding != null )

616

581

encoding = encoding.toUpperCase( Locale.US );

617

582

if( is_interesting_field && encoding != null &&

618

!encoding.equalsIgnoreCase( "8BIT" ) &&

619

!encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

620

//&& !encoding.equalsIgnoreCase( "BASE64" ) )

583

!encoding.equals( "8BIT" ) &&

584

!encoding.equals( "QUOTED-PRINTABLE" ) )

585

//&& !encoding.equals( "BASE64" ) )

621

586

{

622

587

throw new ParseException( R.string.error_vcf_encoding );

623

588

}

627

592

if( charset != null )

628

593

charset = charset.toUpperCase( Locale.US );

629

594

if( charset != null &&

630

!charset.equalsIgnoreCase( "US-ASCII" ) &&

631

!charset.equalsIgnoreCase( "ASCII" ) &&

632

!charset.equalsIgnoreCase( "UTF-8" ) )

595

!charset.equals( "US-ASCII" ) &&

596

!charset.equals( "ASCII" ) &&

597

!charset.equals( "UTF-8" ) )

633

598

{

634

599

throw new ParseException( R.string.error_vcf_charset );

635

600

}

637

602

// do unencoding (or default to a fake unencoding result with

638

603

// the raw string)

639

604

UnencodeResult unencoding_result = null;

640

if( encoding != null &&

641

encoding.equalsIgnoreCase( "QUOTED-PRINTABLE" ) )

642

{

605

if( encoding != null && encoding.equals( "QUOTED-PRINTABLE" ) )

643

606

unencoding_result = unencodeQuotedPrintable( value );

644

}

645

// else if( encoding != null &&

646

// encoding.equalsIgnoreCase( "BASE64" ) )

647

// {

607

// else if( encoding != null && encoding.equals( "BASE64" ) )

648

608

// unencoding_result = unencodeBase64( props[ 1 ], charset );

649

// }

650

609

if( unencoding_result != null ) {

651

610

value = unencoding_result.getBuffer();

652

611

if( unencoding_result.isAnotherLineRequired() )

657

616

// specified for a v2.1 vcard entry, we assume it's US-ASCII)

658

617

if( ( charset == null && _version.equals( "2.1" ) ) ||

659

618

( charset != null && (

660

charset.equalsIgnoreCase( "ASCII" ) ||

661

charset.equalsIgnoreCase( "US-ASCII" ) ) ) )

619

charset.equals( "ASCII" ) ||

620

charset.equals( "US-ASCII" ) ) ) )

662

621

{

663

622

value = transcodeAsciiToUtf8( value );

664

623

}

675

634

// for some entries that have semicolon-separated value parts,

676

635

// check to see if the value ends in an escape character, which

677

636

// indicates that we have a multi-line value

678

if( ( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) ||

679

name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) ||

680

name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) ) &&

637

if( ( name_param_parts[ 0 ].equals( "N" ) ||

638

name_param_parts[ 0 ].equals( "ORG" ) ||

639

name_param_parts[ 0 ].equals( "ADR" ) ) &&

681

640

doesStringEndInAnEscapeChar( string_value ) )

682

641

{

683

642

_parser_multiline_state = MULTILINE_ESCAPED;

685

644

string_value.length() - 1 );

686

645

}

687

646

688

// if we know we're not in an encoding-based multi-line, check

689

// to see if we're in a folded multi-line

647

// now we know whether we're in an encoding multi-line,

648

// determine if we're in a v3 folded multi-line or not

690

649

if( _parser_multiline_state == MULTILINE_NONE &&

691

content_line.doesNextLineLookFolded() )

650

_version.equals( "3.0" ) && next_line_looks_folded )

692

651

{

693

652

_parser_multiline_state = MULTILINE_FOLDED;

694

653

}

706

665

if( complete_value.length() < 1 ) return;

707

666

708

667

// parse some properties

709

if( name_param_parts[ 0 ].equalsIgnoreCase( "N" ) )

668

if( name_param_parts[ 0 ].equals( "N" ) )

710

669

parseN( name_param_parts, complete_value );

711

else if( name_param_parts[ 0 ].equalsIgnoreCase( "FN" ) )

670

else if( name_param_parts[ 0 ].equals( "FN" ) )

712

671

parseFN( name_param_parts, complete_value );

713

else if( name_param_parts[ 0 ].equalsIgnoreCase( "ORG" ) )

672

else if( name_param_parts[ 0 ].equals( "ORG" ) )

714

673

parseORG( name_param_parts, complete_value );

715

else if( name_param_parts[ 0 ].equalsIgnoreCase( "TITLE" ) )

674

else if( name_param_parts[ 0 ].equals( "TITLE" ) )

716

675

parseTITLE( name_param_parts, complete_value );

717

else if( name_param_parts[ 0 ].equalsIgnoreCase( "TEL" ) )

676

else if( name_param_parts[ 0 ].equals( "TEL" ) )

718

677

parseTEL( name_param_parts, complete_value );

719

else if( name_param_parts[ 0 ].equalsIgnoreCase( "EMAIL" ) )

678

else if( name_param_parts[ 0 ].equals( "EMAIL" ) )

720

679

parseEMAIL( name_param_parts, complete_value );

721

else if( name_param_parts[ 0 ].equalsIgnoreCase( "ADR" ) )

680

else if( name_param_parts[ 0 ].equals( "ADR" ) )

722

681

parseADR( name_param_parts, complete_value );

723

else if( name_param_parts[ 0 ].equalsIgnoreCase( "LABEL" ) )

682

else if( name_param_parts[ 0 ].equals( "LABEL" ) )

724

683

parseLABEL( name_param_parts, complete_value );

725

else if( name_param_parts[ 0 ].equalsIgnoreCase( "NOTE" ) )

726

parseNOTE( name_param_parts, complete_value );

727

else if( name_param_parts[ 0 ].equalsIgnoreCase( "BDAY" ) )

728

parseBDAY( name_param_parts, complete_value );

729

684

}

730

685

}

731

686

755

710

{

756

711

String str = parts.get( a );

757

712

758

// Look for parts that end in an escape character, but ignore

759

// the final part. We've already detected escape chars at the

713

// look for parts that end in an escape character, but ignore

714

// the final part. We've already detected escape chars at the

760

715

// end of the final part in parseLine() and handled multi-lines

761

716

// accordingly.

762

717

if( a < parts.size() - 1 &&

803

758

in_escape = false;

804

759

switch( c )

805

760

{

806

case 'T':

807

case 't':

808

// add tab (invalid/non-standard, but accepted)

809

ret.append( '\t' );

810

break;

811

761

case 'N':

812

762

case 'n':

813

763

// add newline

821

771

break;

822

772

default:

823

773

// unknown escape sequence, so add it unescaped

824

// (invalid/non-standard, but accepted)

825

774

ret.append( "\\" );

826

775

ret.append( Character.toChars( c ) );

827

776

break;

852

801

for( int b = 0; b < name_part_parts.length; b++ )

853

802

if( name_part_parts[ b ].length() > 0 )

854

803

{

855

if( value.length() > 0 ) value += " ";

804

if( value.length() == 0 ) value += " ";

856

805

value += name_part_parts[ b ];

857

806

}

858

807

}

977

926

for( int a = 0; a < adr_parts.length; a++ )

978

927

if( adr_parts[ a ].length() > 0 )

979

928

{

980

// version 3.0 vCards allow further splitting by comma

981

if( _version.equals( "3.0" ) )

982

{

983

// split this part in to it's comma-separated bits and

984

// add them on individual lines

985

String[] adr_part_parts =

986

splitValueByCharacter( adr_parts[ a ], ',' );

987

for( int b = 0; b < adr_part_parts.length; b++ )

988

if( adr_part_parts[ b ].length() > 0 )

989

{

990

if( value.length() > 0 ) value += "\n";

991

value += adr_part_parts[ b ];

992

}

993

}

994

else

995

{

996

// add this part on an individual line

997

if( value.length() > 0 ) value += "\n";

998

value += adr_parts[ a ];

999

}

929

// split this part in to it's comma-separated bits

930

String[] adr_part_parts =

931

splitValueByCharacter( adr_parts[ a ], ',' );

932

for( int b = 0; b < adr_part_parts.length; b++ )

933

if( adr_part_parts[ b ].length() > 0 )

934

{

935

if( value.length() > 0 ) value += "\n";

936

value += adr_part_parts[ b ];

937

}

1000

938

}

1001

939

1002

940

Set< String > types = extractTypes( params, Arrays.asList(

1027

965

addAddress( unescapeValue( value ), type );

1028

966

}

1029

967

1030

private void parseNOTE( String[] params, String value )

1031

{

1032

addNote( unescapeValue( value ) );

1033

}

1034

1035

private void parseBDAY( String[] params, String value )

1036

{

1037

setBirthday( value );

1038

}

1039

1040

968

public void finaliseVcard()

1041

969

throws ParseException, ContactNotIdentifiableException

1042

970

{

1043

971

// missing version (and data is present)

1044

if( _version == null && _content_lines != null )

972

if( _version == null && _buffers != null )

1045

973

throw new ParseException( R.string.error_vcf_malformed );

1046

974

1047

975

// finalise the parent class

1050

978

1051

979

/**

1052

980

* Amongst the params, find the value of the first, only, of any with

1053

* the specified name.

1054

*

981

* the specified name

1055

982

* @param params

1056

983

* @param name

1057

984

* @return a value, or null

1063

990

}

1064

991

1065

992

/**

1066

* Amongst the params, find the values of any with the specified name.

1067

*

993

* Amongst the params, find the values of any with the specified name

1068

994

* @param params

1069

995

* @param name

1070

996

* @return an array of values, or null

1074

1000

HashSet< String > ret = new HashSet< String >();

1075

1001

1076

1002

Pattern p = Pattern.compile(

1077

"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$",

1078

Pattern.CASE_INSENSITIVE );

1003

"^" + name + "[ \\t]*=[ \\t]*(\"?)(.*)\\1$" );

1079

1004

for( int i = 0; i < params.length; i++ ) {

1080

1005

Matcher m = p.matcher( params[ i ] );

1081

1006

if( m.matches() )

1086

1011

}

1087

1012

1088

1013

/**

1089

* Amongst the params, return any type values present. For v2.1 vCards,

1090

* those types are just parameters. For v3.0, they are prefixed with

1091

* "TYPE=". There may also be multiple type parameters.

1092

*

1093

* @param params an array of params to look for types in

1094

* @param valid_types an list of upper-case type values to look for

1014

* Amongst the params, return any type values present. For v2.1 vCards,

1015

* those types are just parameters. For v3.0, they are prefixed with

1016

* "TYPE=". There may also be multiple type parameters.

1017

* @param params

1018

* @param a list of type values to look for

1095

1019

* @return a set of present type values

1096

1020

*/

1097

1021

private Set< String > extractTypes( String[] params,

1103

1027

String type_params[] = checkParams( params, "TYPE" );

1104

1028

for( int a = 0; a < type_params.length; a++ )

1105

1029

{

1106

// check for a comma-separated list of types (why? I don't think

1107

// this is in the specs!)

1030

// check for a comma-separated list of types (why? this isn't in

1031

// the specs!)

1108

1032

String[] parts = type_params[ a ].split( "," );

1109

for( int i = 0; i < parts.length; i++ ) {

1110

String ucpart = parts[ i ].toUpperCase( Locale.US );

1111

if( valid_types.contains( ucpart ) )

1112

types.add( ucpart );

1113

}

1033

for( int i = 0; i < parts.length; i++ )

1034

if( valid_types.contains( parts[ i ] ) )

1035

types.add( parts[ i ] );

1114

1036

}

1115

1037

1116

1038

// get 2.1-style type param

1117

1039

if( _version.equals( "2.1" ) ) {

1118

for( int i = 1; i < params.length; i++ ) {

1119

String ucparam = params[ i ].toUpperCase( Locale.US );

1120

if( valid_types.contains( ucparam ) )

1121

types.add( ucparam );

1122

}

1040

for( int i = 1; i < params.length; i++ )

1041

if( valid_types.contains( params[ i ] ) )

1042

types.add( params[ i ] );

1123

1043

}

1124

1044

1125

1045

return types;

1147

1067

else if( ch == '=' && i == in.limit() - 1 )

1148

1068

{

1149

1069

// we found a '=' at the end of a line signifying a multi-

1150

// line string, so we don't add it

1070

// line string, so we don't add it.

1151

1071

another = true;

1152

1072

continue;

1153

1073

}