1/*
2* Conditions Of Use
3*
4* This software was developed by employees of the National Institute of
5* Standards and Technology (NIST), an agency of the Federal Government.
6* Pursuant to title 15 Untied States Code Section 105, works of NIST
7* employees are not subject to copyright protection in the United States
8* and are considered to be in the public domain.  As a result, a formal
9* license is not needed to use the software.
10*
11* This software is provided by NIST as a service and is expressly
12* provided "AS IS."  NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED
13* OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
14* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT
15* AND DATA ACCURACY.  NIST does not warrant or make any representations
16* regarding the use of the software or the results thereof, including but
17* not limited to the correctness, accuracy, reliability or usefulness of
18* the software.
19*
20* Permission to use this software is contingent upon your acceptance
21* of the terms of this agreement
22*
23* .
24*
25*/
26package gov.nist.core;
27
28import java.util.*;
29import java.text.ParseException;
30
31/** Base string token splitter.
32*
33*@version 1.2
34*
35*@author M. Ranganathan   <br/>
36*
37*
38*
39*/
40
41public class StringTokenizer {
42
43    protected String buffer;
44    protected int bufferLen;
45    protected int ptr;
46    protected int savedPtr;
47
48    protected StringTokenizer() {
49    }
50
51    public StringTokenizer(String buffer) {
52        this.buffer = buffer;
53        bufferLen = buffer.length();
54        ptr = 0;
55    }
56
57    public String nextToken() {
58        int startIdx = ptr;
59
60        while (ptr < bufferLen) {
61            char c = buffer.charAt(ptr);
62            ptr++;
63            if (c == '\n') {
64                break;
65            }
66        }
67
68        return buffer.substring(startIdx, ptr);
69    }
70
71    public boolean hasMoreChars() {
72        return ptr < bufferLen;
73    }
74
75    public static boolean isHexDigit(char ch) {
76        return (ch >= 'A' && ch <= 'F') ||
77               (ch >= 'a' && ch <= 'f') ||
78               isDigit(ch);
79    }
80
81    public static boolean isAlpha(char ch) {
82        if (ch <= 127) {
83            return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
84        }
85        else {
86            return Character.isLowerCase(ch) || Character.isUpperCase(ch);
87        }
88    }
89
90    public static boolean isDigit(char ch) {
91        if (ch <= 127) {
92            return (ch <= '9' && ch >= '0');
93        }
94        else {
95            return Character.isDigit(ch);
96        }
97    }
98
99    public static boolean isAlphaDigit(char ch) {
100        if (ch <= 127) {
101            return (ch >= 'a' && ch <= 'z') ||
102                (ch >= 'A' && ch <= 'Z') ||
103                (ch <= '9' && ch >= '0');
104        }
105        else {
106            return Character.isLowerCase(ch) ||
107                Character.isUpperCase(ch) ||
108                Character.isDigit(ch);
109        }
110    }
111
112    public String getLine() {
113        int startIdx = ptr;
114        while (ptr < bufferLen && buffer.charAt(ptr) != '\n') {
115            ptr++;
116        }
117        if (ptr < bufferLen && buffer.charAt(ptr) == '\n') {
118            ptr++;
119        }
120        return buffer.substring(startIdx, ptr);
121    }
122
123    public String peekLine() {
124        int curPos = ptr;
125        String retval = this.getLine();
126        ptr = curPos;
127        return retval;
128    }
129
130    public char lookAhead() throws ParseException {
131        return lookAhead(0);
132    }
133
134    public char lookAhead(int k) throws ParseException {
135        // Debug.out.println("ptr = " + ptr);
136        try {
137            return buffer.charAt(ptr + k);
138        }
139        catch (IndexOutOfBoundsException e) {
140            return '\0';
141        }
142    }
143
144    public char getNextChar() throws ParseException {
145        if (ptr >= bufferLen)
146            throw new ParseException(
147                buffer + " getNextChar: End of buffer",
148                ptr);
149        else
150            return buffer.charAt(ptr++);
151    }
152
153    public void consume() {
154        ptr = savedPtr;
155    }
156
157    public void consume(int k) {
158        ptr += k;
159    }
160
161    /** Get a Vector of the buffer tokenized by lines
162     */
163    public Vector<String> getLines() {
164        Vector<String> result = new Vector<String>();
165        while (hasMoreChars()) {
166            String line = getLine();
167            result.addElement(line);
168        }
169        return result;
170    }
171
172    /** Get the next token from the buffer.
173    */
174    public String getNextToken(char delim) throws ParseException {
175        int startIdx = ptr;
176        while (true) {
177            char la = lookAhead(0);
178            if (la == delim)
179                break;
180            else if (la == '\0')
181                throw new ParseException("EOL reached", 0);
182            consume(1);
183        }
184        return buffer.substring(startIdx, ptr);
185    }
186
187    /** get the SDP field name of the line
188     *  @return String
189     */
190    public static String getSDPFieldName(String line) {
191        if (line == null)
192            return null;
193        String fieldName = null;
194        try {
195            int begin = line.indexOf("=");
196            fieldName = line.substring(0, begin);
197        } catch (IndexOutOfBoundsException e) {
198            return null;
199        }
200        return fieldName;
201    }
202
203}
204
205