~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt16.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

392

else

393

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int16.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

394

} else if (ch == '%' || ch == 'I') {

395

ReaderRead();

396

if (unsigned)

397

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt32.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

398

else

399

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

400

} else if (ch == '&' || ch == 'L') {

401

ReaderRead();

402

if (unsigned)

403

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt64.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

404

else

405

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);

406

} else if (ishex) {

407

ulong number = UInt64.Parse(digit, NumberStyles.HexNumber);

408

if (number > uint.MaxValue) {

409

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((long)number), literalFormat);

410

} else {

411

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((int)number), literalFormat);

412

}

413

}

414

} catch (OverflowException ex) {

415

errors.Error(Line, Col, ex.Message);

416

return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.None);

417

}

418

}

419

Token nextToken = null; // if we accedently read a 'dot'

420

if (!isdouble && ReaderPeek() == '.') { // read floating point number

421

ReaderRead();

422

if (ReaderPeek() != -1 && Char.IsDigit((char)ReaderPeek())) {

423

isdouble = true; // double is default

424

if (ishex || isokt) {

425

errors.Error(Line, Col, String.Format("No hexadecimal or oktadecimal floating point values allowed"));

426

}

427

digit += '.';

428

while (ReaderPeek() != -1 && Char.IsDigit((char)ReaderPeek())){ // read decimal digits beyond the dot

429

digit += (char)ReaderRead();

430

}

431

} else {

432

nextToken = new Token(Tokens.Dot, Col - 1, Line);

433

}

434

}

435

436

if (ReaderPeek() != -1 && PeekUpperChar() == 'E') { // read exponent

437

isdouble = true;

438

digit += (char)ReaderRead();

439

if (ReaderPeek() != -1 && (ReaderPeek() == '-' || ReaderPeek() == '+')) {

440

digit += (char)ReaderRead();

441

}

442

while (ReaderPeek() != -1 && Char.IsDigit((char)ReaderPeek())) { // read exponent value

443

digit += (char)ReaderRead();

444

}

445

}

446

447

if (ReaderPeek() != -1) {

448

switch (PeekUpperChar()) {

449

case 'R':

450

case '#':

451

ReaderRead();

452

isdouble = true;

453

break;

454

case 'D':

455

case '@':

456

ReaderRead();

457

isdecimal = true;

458

break;

459

case 'F':

460

case '!':

461

ReaderRead();

462

issingle = true;

463

break;

464

}

465

}

466

467

try {

468

if (issingle) {

469

return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), Single.Parse(digit, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);

470

}

471

if (isdecimal) {

472

return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), Decimal.Parse(digit, NumberStyles.Currency | NumberStyles.AllowExponent, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);

473

}

474

if (isdouble) {

475

return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), Double.Parse(digit, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);

476

}

477

} catch (FormatException) {

478

errors.Error(Line, Col, String.Format("{0} is not a parseable number", digit));

479

if (issingle)

480

return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), 0f, LiteralFormat.DecimalNumber);

481

if (isdecimal)

482

return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), 0m, LiteralFormat.DecimalNumber);

483

if (isdouble)

484

return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), 0.0, LiteralFormat.DecimalNumber);

485

}

486

Token token;

487

try {

488

token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), ishex ? LiteralFormat.HexadecimalNumber : LiteralFormat.DecimalNumber);

489

} catch (Exception) {

490

try {

491

token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number), ishex ? LiteralFormat.HexadecimalNumber : LiteralFormat.DecimalNumber);

492

} catch (FormatException) {

493

errors.Error(Line, Col, String.Format("{0} is not a parseable number", digit));

494

// fallback, when nothing helps :)

495

token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.DecimalNumber);

496

} catch (OverflowException) {

497

errors.Error(Line, Col, String.Format("{0} is too long for a integer literal", digit));

498

// fallback, when nothing helps :)

499

token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.DecimalNumber);

500

}

501

}

502

token.next = nextToken;

503

return token;

504

}

505

506

void ReadPreprocessorDirective()

507

{

508

Location start = new Location(Col - 1, Line);

509

string directive = ReadIdent('#');

510

string argument = ReadToEndOfLine();

511

this.specialTracker.AddPreprocessingDirective(new PreprocessingDirective(directive, argument.Trim(), start, new Location(start.Column + directive.Length + argument.Length, start.Line)));

512

}

513

514

string ReadDate()

515

{

516

char ch = '\0';

517

sb.Length = 0;

518

int nextChar;

519

while ((nextChar = ReaderRead()) != -1) {

520

ch = (char)nextChar;

521

if (ch == '#') {

522

break;

523

} else if (ch == '\n') {

524

errors.Error(Line, Col, String.Format("No return allowed inside Date literal"));

525

} else {

526

sb.Append(ch);

527

}

528

}

529

if (ch != '#') {

530

errors.Error(Line, Col, String.Format("End of File reached before Date literal terminated"));

531

}

532

return sb.ToString();

533

}

534

535

string ReadString()

536

{

537

char ch = '\0';

538

sb.Length = 0;

539

int nextChar;

540

while ((nextChar = ReaderRead()) != -1) {

541

ch = (char)nextChar;

542

if (ch == '"') {

543

if (ReaderPeek() != -1 && ReaderPeek() == '"') {

544

sb.Append('"');

545

ReaderRead();

546

} else {

547

break;

548

}

549

} else if (ch == '\n') {

550

errors.Error(Line, Col, String.Format("No return allowed inside String literal"));

551

} else {

552

sb.Append(ch);

553

}

554

}

555

if (ch != '"') {

556

errors.Error(Line, Col, String.Format("End of File reached before String terminated "));

557

}

558

return sb.ToString();

559

}

560

561

void ReadComment()

562

{

563

Location startPos = new Location(Col, Line);

564

sb.Length = 0;

565

StringBuilder curWord = specialCommentHash != null ? new StringBuilder() : null;

566

int missingApostrophes = 2; // no. of ' missing until it is a documentation comment

567

int nextChar;

568

while ((nextChar = ReaderRead()) != -1) {

569

char ch = (char)nextChar;

570

571

if (HandleLineEnd(ch)) {

572

break;

573

}

574

575

sb.Append(ch);

576

577

if (missingApostrophes > 0) {

578

if (ch == '\'' || ch == '\u2018' || ch == '\u2019') {

579

if (--missingApostrophes == 0) {

580

specialTracker.StartComment(CommentType.Documentation, isAtLineBegin, startPos);

581

sb.Length = 0;

582

}

583

} else {

584

specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);

585

missingApostrophes = 0;

586

}

587

}

588

589

if (specialCommentHash != null) {

590

if (Char.IsLetter(ch)) {

591

curWord.Append(ch);

592

} else {

593

string tag = curWord.ToString();

594

curWord.Length = 0;

595

if (specialCommentHash.ContainsKey(tag)) {

596

Location p = new Location(Col, Line);

597

string comment = ch + ReadToEndOfLine();

598

this.TagComments.Add(new TagComment(tag, comment, isAtLineBegin, p, new Location(Col, Line)));

599

sb.Append(comment);

600

break;

601

}

602

}

603

}

604

}

605

if (missingApostrophes > 0) {

606

specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);

607

}

608

specialTracker.AddString(sb.ToString());

609

specialTracker.FinishComment(new Location(Col, Line));

610

}

611

612

Token ReadOperator(char ch)

613

{

614

int x = Col - 1;

615

int y = Line;

616

switch(ch) {

617

case '+':

618

switch (ReaderPeek()) {

619

case '=':

620

ReaderRead();

621

return new Token(Tokens.PlusAssign, x, y);

622

default:

623

break;

624

}

625

return new Token(Tokens.Plus, x, y);

626

case '-':

627

switch (ReaderPeek()) {

628

case '=':

629

ReaderRead();

630

return new Token(Tokens.MinusAssign, x, y);

631

default:

632

break;

633

}

634

return new Token(Tokens.Minus, x, y);

635

case '*':

636

switch (ReaderPeek()) {

637

case '=':

638

ReaderRead();

639

return new Token(Tokens.TimesAssign, x, y);

640

default:

641

break;

642

}

643

return new Token(Tokens.Times, x, y, "*");

644

case '/':

645

switch (ReaderPeek()) {

646

case '=':

647

ReaderRead();

648

return new Token(Tokens.DivAssign, x, y);

649

default:

650

break;

651

}

652

return new Token(Tokens.Div, x, y);

653

case '\\':

654

switch (ReaderPeek()) {

655

case '=':

656

ReaderRead();

657

return new Token(Tokens.DivIntegerAssign, x, y);

658

default:

659

break;

660

}

661

return new Token(Tokens.DivInteger, x, y);

662

case '&':

663

switch (ReaderPeek()) {

664

case '=':

665

ReaderRead();

666

return new Token(Tokens.ConcatStringAssign, x, y);

667

default:

668

break;

669

}

670

return new Token(Tokens.ConcatString, x, y);

671

case '^':

672

switch (ReaderPeek()) {

673

case '=':

674

ReaderRead();

675

return new Token(Tokens.PowerAssign, x, y);

676

default:

677

break;

678

}

679

return new Token(Tokens.Power, x, y);

680

case ':':

681

return new Token(Tokens.Colon, x, y);

682

case '=':

683

return new Token(Tokens.Assign, x, y);

684

case '<':

685

switch (ReaderPeek()) {

686

case '=':

687

ReaderRead();

688

return new Token(Tokens.LessEqual, x, y);

689

case '>':

690

ReaderRead();

691

return new Token(Tokens.NotEqual, x, y);

692

case '<':

693

ReaderRead();

694

switch (ReaderPeek()) {

695

case '=':

696

ReaderRead();

697

return new Token(Tokens.ShiftLeftAssign, x, y);

698

default:

699

break;

700

}

701

return new Token(Tokens.ShiftLeft, x, y);

702

}

703

return new Token(Tokens.LessThan, x, y);

704

case '>':

705

switch (ReaderPeek()) {

706

case '=':

707

ReaderRead();

708

return new Token(Tokens.GreaterEqual, x, y);

709

case '>':

710

ReaderRead();

711

if (ReaderPeek() != -1) {

712

switch (ReaderPeek()) {

713

case '=':

714

ReaderRead();

715

return new Token(Tokens.ShiftRightAssign, x, y);

716

default:

717

break;

718

}

719

}

720

return new Token(Tokens.ShiftRight, x, y);

721

}

722

return new Token(Tokens.GreaterThan, x, y);

723

case ',':

724

return new Token(Tokens.Comma, x, y);

725

case '.':

726

// Prevent OverflowException when Peek returns -1

727

int tmp = ReaderPeek();

728

if (tmp > 0 && Char.IsDigit((char)tmp)) {

729

return ReadDigit('.', Col);

730

}

731

return new Token(Tokens.Dot, x, y);

732

case '(':

733

return new Token(Tokens.OpenParenthesis, x, y);

734

case ')':

735

return new Token(Tokens.CloseParenthesis, x, y);

736

case '{':

737

return new Token(Tokens.OpenCurlyBrace, x, y);

738

case '}':

739

return new Token(Tokens.CloseCurlyBrace, x, y);

740

case '?':

741

return new Token(Tokens.QuestionMark, x, y);

742

case '!':

743

return new Token(Tokens.ExclamationMark, x, y);

744

}

745

return null;

746

}

747

748

public override void SkipCurrentBlock(int targetToken)

749

{

750

int lastKind = -1;

751

int kind = base.lastToken.kind;

752

while (kind != Tokens.EOF &&

753

!(lastKind == Tokens.End && kind == targetToken))

754

{

755

lastKind = kind;

756

NextToken();

757

kind = lastToken.kind;

758

}

759

}

760

}

761

}

Older »