Package org.antlr.misc

Examples of org.antlr.misc.BitSet

582
583
584
585
586
587
588
589
590
591
592
593
    if ( follow.tokenTypeSet==null ) {
      words = new long[1];
            tokenTypeList = new ArrayList<Integer>();
        }
    else {
      BitSet bits = BitSet.of(follow.tokenTypeSet);
      words = bits.toPackedArray();
            tokenTypeList = follow.tokenTypeSet.toList();
        }
    // use the target to convert to hex strings (typically)
    String[] wordStrings = new String[words.length];
    for (int j = 0; j < words.length; j++) {
View Full Code Here
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
    List<Integer> unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("number of unreachable alts", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = equeue.warnings.get(0);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
              msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List<Label> labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      RecursionOverflowMessage recMsg = null;
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List<Integer> nonDetAlts = null;
      if ( nondetMsg!=null ) {
        nonDetAlts =
          nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      }
      else {
        recMsg = getRecursionOverflowMessage(equeue.warnings);
        if ( recMsg!=null ) {
          //nonDetAlts = new ArrayList(recMsg.alts);
        }
      }
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertTrue("found no nondet alts; expecting: "+
              str(expectingNonDetAlts),
              nondetMsg!=null||recMsg!=null);
    }
View Full Code Here
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
    //System.out.print(result);
    List<Integer> unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("unreachable alts mismatch", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = getNonDeterminismMessage(equeue.warnings);
      assertNotNull("no nondeterminism warning?", msg);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
      msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List<Label> labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNotNull("found no nondet alts; expecting: "+
                    str(expectingNonDetAlts), nondetMsg);
      List<Integer> nonDetAlts =
        nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             nondetMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
      // not expecting any nondet alts, make sure there are none
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNull("found nondet alts, but expecting none", nondetMsg);
    }

    if ( expectingInsufficientPredAlts!=null ) {
      GrammarInsufficientPredicatesMessage insuffPredMsg =
        getGrammarInsufficientPredicatesMessage(equeue.warnings);
      assertNotNull("found no GrammarInsufficientPredicatesMessage alts; expecting: "+
                    str(expectingNonDetAlts), insuffPredMsg);
      Map<Integer, Set<Token>> locations = insuffPredMsg.altToLocations;
      Set<Integer> actualAlts = locations.keySet();
      BitSet s = new BitSet();
      s.addAll(expectingInsufficientPredAlts);
      BitSet s2 = new BitSet();
      s2.addAll(actualAlts);
      assertEquals("mismatch between insufficiently covered alts", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             insuffPredMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
View Full Code Here
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
    //System.out.print(result);
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("unreachable alts mismatch", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = getNonDeterminismMessage(equeue.warnings);
      assertNotNull("no nondeterminism warning?", msg);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
      msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNotNull("found no nondet alts; expecting: "+
                    str(expectingNonDetAlts), nondetMsg);
      List nonDetAlts =
        nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             nondetMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
      // not expecting any nondet alts, make sure there are none
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNull("found nondet alts, but expecting none", nondetMsg);
    }

    if ( expectingInsufficientPredAlts!=null ) {
      GrammarInsufficientPredicatesMessage insuffPredMsg =
        getGrammarInsufficientPredicatesMessage(equeue.warnings);
      assertNotNull("found no GrammarInsufficientPredicatesMessage alts; expecting: "+
                    str(expectingNonDetAlts), insuffPredMsg);
      Map<Integer, Set<Token>> locations = insuffPredMsg.altToLocations;
      Set actualAlts = locations.keySet();
      BitSet s = new BitSet();
      s.addAll(expectingInsufficientPredAlts);
      BitSet s2 = new BitSet();
      s2.addAll(actualAlts);
      assertEquals("mismatch between insufficiently covered alts", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             insuffPredMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
View Full Code Here
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("number of unreachable alts", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = (Message)equeue.warnings.get(0);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
              msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      RecursionOverflowMessage recMsg = null;
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List nonDetAlts = null;
      if ( nondetMsg!=null ) {
        nonDetAlts =
          nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      }
      else {
        recMsg = getRecursionOverflowMessage(equeue.warnings);
        if ( recMsg!=null ) {
          //nonDetAlts = new ArrayList(recMsg.alts);
        }
      }
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertTrue("found no nondet alts; expecting: "+
              str(expectingNonDetAlts),
              nondetMsg!=null||recMsg!=null);
    }
View Full Code Here
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
    //System.out.print(result);
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("unreachable alts mismatch", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = getNonDeterminismMessage(equeue.warnings);
      assertNotNull("no nondeterminism warning?", msg);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
      msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNotNull("found no nondet alts; expecting: "+
                    str(expectingNonDetAlts), nondetMsg);
      List nonDetAlts =
        nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             nondetMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
      // not expecting any nondet alts, make sure there are none
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNull("found nondet alts, but expecting none", nondetMsg);
    }

    if ( expectingInsufficientPredAlts!=null ) {
      GrammarInsufficientPredicatesMessage insuffPredMsg =
        getGrammarInsufficientPredicatesMessage(equeue.warnings);
      assertNotNull("found no GrammarInsufficientPredicatesMessage alts; expecting: "+
                    str(expectingNonDetAlts), insuffPredMsg);
      Map<Integer, Set<Token>> locations = insuffPredMsg.altToLocations;
      Set actualAlts = locations.keySet();
      BitSet s = new BitSet();
      s.addAll(expectingInsufficientPredAlts);
      BitSet s2 = new BitSet();
      s2.addAll(actualAlts);
      assertEquals("mismatch between insufficiently covered alts", s, s2);
      assertEquals("mismatch between expected hasPredHiddenByAction", hasPredHiddenByAction,
             insuffPredMsg.problemState.dfa.hasPredicateBlockedByAction);
    }
    else {
View Full Code Here
587
588
589
590
591
592
593
594
595
596
597
598
    if ( follow.tokenTypeSet==null ) {
      words = new long[1];
            tokenTypeList = new ArrayList();
        }
    else {
      BitSet bits = BitSet.of(follow.tokenTypeSet);
      words = bits.toPackedArray();
            tokenTypeList = follow.tokenTypeSet.toList();
        }
    // use the target to convert to hex strings (typically)
    String[] wordStrings = new String[words.length];
    for (int j = 0; j < words.length; j++) {
View Full Code Here
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("number of unreachable alts", 0, unreachableAlts.size());
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = (Message)equeue.warnings.get(0);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
              msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      RecursionOverflowMessage recMsg = null;
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List nonDetAlts = null;
      if ( nondetMsg!=null ) {
        nonDetAlts =
          nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      }
      else {
        recMsg = getRecursionOverflowMessage(equeue.warnings);
        if ( recMsg!=null ) {
          //nonDetAlts = new ArrayList(recMsg.alts);
        }
      }
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertTrue("found no nondet alts; expecting: "+
              str(expectingNonDetAlts),
              nondetMsg!=null||recMsg!=null);
    }
View Full Code Here
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("number of unreachable alts", 0,
             unreachableAlts!=null?unreachableAlts.size():0);
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = (Message)equeue.warnings.get(0);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
              msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      RecursionOverflowMessage recMsg = null;
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List nonDetAlts = null;
      if ( nondetMsg!=null ) {
        nonDetAlts =
          nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      }
      else {
        recMsg = getRecursionOverflowMessage(equeue.warnings);
        if ( recMsg!=null ) {
          //nonDetAlts = new ArrayList(recMsg.alts);
        }
      }
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
      assertTrue("found no nondet alts; expecting: "+
              str(expectingNonDetAlts),
              nondetMsg!=null||recMsg!=null);
    }
View Full Code Here
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
    //System.out.print(result);
    List unreachableAlts = dfa.getUnreachableAlts();

    // make sure unreachable alts are as expected
    if ( expectingUnreachableAlts!=null ) {
      BitSet s = new BitSet();
      s.addAll(expectingUnreachableAlts);
      BitSet s2 = new BitSet();
      s2.addAll(unreachableAlts);
      assertEquals("unreachable alts mismatch", s, s2);
    }
    else {
      assertEquals("unreachable alts mismatch", 0, unreachableAlts.size());
    }

    // check conflicting input
    if ( expectingAmbigInput!=null ) {
      // first, find nondet message
      Message msg = (Message)equeue.warnings.get(0);
      assertTrue("expecting nondeterminism; found "+msg.getClass().getName(),
      msg instanceof GrammarNonDeterminismMessage);
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      List labels =
        nondetMsg.probe.getSampleNonDeterministicInputSequence(nondetMsg.problemState);
      String input = nondetMsg.probe.getInputSequenceDisplay(labels);
      assertEquals(expectingAmbigInput, input);
    }

    // check nondet alts
    if ( expectingNonDetAlts!=null ) {
      GrammarNonDeterminismMessage nondetMsg =
        getNonDeterminismMessage(equeue.warnings);
      assertNotNull("found no nondet alts; expecting: "+
                    str(expectingNonDetAlts), nondetMsg);
      List nonDetAlts =
        nondetMsg.probe.getNonDeterministicAltsForState(nondetMsg.problemState);
      // compare nonDetAlts with expectingNonDetAlts
      BitSet s = new BitSet();
      s.addAll(expectingNonDetAlts);
      BitSet s2 = new BitSet();
      s2.addAll(nonDetAlts);
      assertEquals("nondet alts mismatch", s, s2);
    }
    else {
      // not expecting any nondet alts, make sure there are none
      GrammarNonDeterminismMessage nondetMsg =
View Full Code Here
TOP

Related Classes of org.antlr.misc.BitSet

  • org.antlr.codegen.CodeGenerator
  • org.antlr.test.TestDFAConversion
  • org.antlr.test.TestSemanticPredicates
  • java.util.Iterator
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.