Cross Reference: /libcore/ojluni/src/main/java/java/net/URI.java

Lines Matching defs:start
546      *   domain label are permitted to start with an <i>alphanum</i>
2264             // Note start of segment
2895         private String substring(int start, int end) {
2896             return input.substring(start, end);
2906         // Tells whether start < end and, if so, whether charAt(start) == c
2908         private boolean at(int start, int end, char c) {
2909             return (start < end) && (charAt(start) == c);
2912         // Tells whether start + s.length() < end and, if so,
2913         // whether the chars at the start position match s exactly
2915         private boolean at(int start, int end, String s) {
2916             int p = start;
2934         // convention of taking the current start position and end index as
2935         // their first two arguments.  The start is inclusive while the end is
2936         // exclusive, just as in the String class, i.e., a start/end pair
2937         // denotes the left-open interval [start, end) of the input string.
2944         //     int p = start;
2957         // Scan a specific char: If the char at the given start position is
2959         // start position.
2961         private int scan(int start, int end, char c) {
2962             if ((start < end) && (charAt(start) == c))
2963                 return start + 1;
2964             return start;
2967         // Scan forward from the given start position.  Stop at the first char
2971         // of the input string is returned).  May return the start position if
2974         private int scan(int start, int end, String err, String stop) {
2975             int p = start;
2988         // with the given first char (i.e., charAt(start) == c).
2993         private int scanEscape(int start, int n, char first)
2996             int p = start;
3017         private int scan(int start, int n, long lowMask, long highMask)
3020             int p = start;
3039         // Check that each of the chars in [start, end) matches the given mask
3041         private void checkChars(int start, int end,
3046             int p = scan(start, end, lowMask, highMask);
3116         private int parseHierarchical(int start, int n)
3119             int p = start;
3153         private int parseAuthority(int start, int n)
3156             int p = start;
3223         private int parseServer(int start, int n)
3226             int p = start;
3289         private int scanByte(int start, int n)
3292             int p = start;
3303         // then we only require that it start with an IPv4 address.
3305         // If the interval does not contain or start with (depending upon the
3314         private int scanIPv4Address(int start, int n, boolean strict)
3317             int p = start;
3342         private int takeIPv4Address(int start, int n, String expected)
3345             int p = scanIPv4Address(start, n, true);
3346             if (p <= start)
3347                 failExpecting(expected, start);
3355         private int parseIPv4Address(int start, int n) {
3359                 p = scanIPv4Address(start, n, false);
3366             if (p > start && p < n) {
3375             if (p > start)
3376                 host = substring(start, p);
3385         private int parseHostname(int start, int n)
3388             int p = start;
3424                 failExpecting("hostname", start);
3428             if (l > start && !match(charAt(l), L_ALPHA, H_ALPHA)) {
3432             host = substring(start, p);
3480         private int parseIPv6Reference(int start, int n)
3483             int p = start;
3503                 fail("Malformed IPv6 address", start);
3505                 fail("IPv6 address too long", start);
3507                 fail("IPv6 address too short", start);
3509                 fail("Malformed IPv6 address", start);
3514         private int scanHexPost(int start, int n)
3517             int p = start;
3540         private int scanHexSeq(int start, int n)
3543             int p = start;