fe952afa2f9c313a6d66f65af028189e7a57e39d
[IRC.git] / Robust / src / ClassLibrary / SSJava / String.java
1 public class String {
2
3   locdef{
4     data<proc,proc<c,c<in,in*,c*,proc*,data*
5   }
6
7   @LOC("data") char value[];
8   @LOC("data") int count;
9   @LOC("data") int offset;
10   @LOC("data") private int cachedHashcode;
11
12   private String() {
13   }
14
15   public String(@LOC("in") char c) {
16     @LOC("data") char[] str = new char[1];
17     str[0] = c;
18     String(str);
19   }
20
21   public String(@LOC("in") char str[]) {
22     @LOC("in") char charstr[]=new char[str.length];
23     for(@LOC("c") int i=0; i<str.length; i++)
24       charstr[i]=str[i];
25     this.value=charstr;
26     this.count=str.length;
27     this.offset=0;
28   }
29
30   public String(@LOC("in") byte str[]) {
31     @LOC("in") char charstr[]=new char[str.length];
32     for(@LOC("c") int i=0; i<str.length; i++)
33       charstr[i]=(char)str[i];
34     this.value=charstr;
35     this.count=str.length;
36     this.offset=0;
37   }
38
39   public String(@LOC("in") byte str[], @LOC("in") int offset, @LOC("in") int length) {
40     if (length>(str.length-offset))
41       length=str.length-offset;
42     @LOC("in") char charstr[]=new char[length];
43     for(@LOC("c")int i=0; i<length; i++)
44       charstr[i]=(char)str[i+offset];
45     this.value=charstr;
46     this.count=length;
47     this.offset=0;
48   }
49
50   public String(@LOC("in") byte str[], @LOC("in") String encoding) {
51     @LOC("data") int length = this.count;
52     if (length>(str.length))
53       length=str.length;
54     @LOC("data") char charstr[]=new char[length];
55     for(@LOC("c") int i=0; i<length; i++)
56       charstr[i]=(char)str[i];
57     this.value=charstr;
58     this.count=length;
59     this.offset=0;
60   }
61
62   public String(@LOC("in") char str[], @LOC("in") int offset, @LOC("in") int length) {
63     if (length>(str.length-offset))
64       length=str.length-offset;
65     @LOC("in") char charstr[]=new char[length];
66     for(@LOC("c") int i=0; i<length; i++)
67       charstr[i]=str[i+offset];
68     this.value=charstr;
69     this.count=length;
70     this.offset=0;
71   }
72
73   public String(@LOC("in") String str) {
74     this.value=str.value;
75     this.count=str.count;
76     this.offset=str.offset;
77   }
78   
79   public String concat(@LOC("in") String str) {
80     @LOC("data") String newstr=new String();
81     newstr.count=this.count+str.count;
82     @LOC("data") char charstr[]=new char[newstr.count];
83     newstr.value=charstr;
84     newstr.offset=0;
85     for(@LOC("c") int i=0; i<count; i++) {
86       charstr[i]=value[i+offset];
87     }
88     for(@LOC("c") int i=0; i<str.count; i++) {
89       charstr[i+count]=str.value[i+str.offset];
90     }
91     return newstr;
92   }
93   
94   /*
95   public String(StringBuffer strbuf) {
96     value=new char[strbuf.length()];
97     count=strbuf.length();
98     offset=0;
99     for(int i=0; i<count; i++)
100       value[i]=strbuf.value[i];
101   }
102    */
103   
104   /*
105   public boolean endsWith(@LOC("in") String suffix) {
106     return regionMatches(count - suffix.count, suffix, 0, suffix.count);
107   }
108
109
110   public String substring(@LOC("in") int beginIndex) {
111     return substring(beginIndex, this.count);
112   }
113
114   public String subString(@LOC("in") int beginIndex, @LOC("in") int endIndex) {
115     return substring(beginIndex, endIndex);
116   }
117
118   public String substring(@LOC("in") int beginIndex, @LOC("in") int endIndex) {
119     String str=new String();
120     if (beginIndex>this.count||endIndex>this.count||beginIndex>endIndex) {
121       // FIXME
122       System.printString("Index error: "+beginIndex+" "+endIndex+" "+count+"\n"+this);
123     }
124     str.value=this.value;
125     str.count=endIndex-beginIndex;
126     str.offset=this.offset+beginIndex;
127     return str;
128   }
129
130   public String subString(@LOC("in") int beginIndex) {
131     return this.subString(beginIndex, this.count);
132   }
133
134   public int lastindexOf(@LOC("in") int ch) {
135     return this.lastindexOf(ch, count - 1);
136   }
137
138   public int lastIndexOf(@LOC("in") char ch) {
139     return this.lastindexOf((int)ch, count - 1);
140   }
141
142   public static String concat2(@LOC("in") String s1, @LOC("in") String s2) {
143     if (s1==null)
144       return "null".concat(s2);
145     else
146       return s1.concat(s2);
147   }
148
149   public int lastindexOf(@LOC("in") int ch, @LOC("in") int fromIndex) {
150     for(int i=fromIndex; i>0; i--)
151       if (this.charAt(i)==ch)
152         return i;
153     return -1;
154   }
155
156   public String replace(@LOC("in") char oldch, @LOC("in") char newch) {
157     char[] buffer=new char[count];
158     for(int i=0; i<count; i++) {
159       char x=charAt(i);
160       if (x==oldch)
161         x=newch;
162       buffer[i]=x;
163     }
164     return new String(buffer);
165   }
166
167   public String toUpperCase() {
168     char[] buffer=new char[count];
169     for(int i=0; i<count; i++) {
170       char x=charAt(i);
171       if (x>='a'&&x<='z') {
172         x=(char) ((x-'a')+'A');
173       }
174       buffer[i]=x;
175     }
176     return new String(buffer);
177   }
178
179   public String toLowerCase() {
180     char[] buffer=new char[count];
181     for(int i=0; i<count; i++) {
182       char x=charAt(i);
183       if (x>='A'&&x<='Z') {
184         x=(char) ((x-'A')+'a');
185       }
186       buffer[i]=x;
187     }
188     return new String(buffer);
189   }
190
191   public int indexOf(@LOC("in") int ch) {
192     return this.indexOf(ch, 0);
193   }
194
195   public int indexOf(@LOC("in") int ch, @LOC("in") int fromIndex) {
196     for(int i=fromIndex; i<count; i++)
197       if (this.charAt(i)==ch)
198         return i;
199     return -1;
200   }
201
202   public int indexOf(@LOC("in") String str) {
203     return this.indexOf(str, 0);
204   }
205
206   public int indexOf(@LOC("in") String str, @LOC("in") int fromIndex) {
207     if (fromIndex<0)
208       fromIndex=0;
209     for(int i=fromIndex; i<=(count-str.count); i++)
210       if (regionMatches(i, str, 0, str.count))
211         return i;
212     return -1;
213   }
214
215   public int indexOfIgnoreCase(@LOC("in") String str, @LOC("in") int fromIndex) {
216     if (fromIndex < 0) 
217       fromIndex = 0;
218   }
219
220   public int lastIndexOf(@LOC("in") String str, @LOC("in") int fromIndex) {
221     int k=count-str.count;
222     if (k>fromIndex)
223       k=fromIndex;
224     for(; k>=0; k--) {
225       if (regionMatches(k, str, 0, str.count))
226         return k;
227     }
228     return -1;
229   }
230
231   public int lastIndexOf(@LOC("in") String str) {
232     return lastIndexOf(str, count-str.count);
233   }
234
235   public boolean startsWith(@LOC("in") String str) {
236     return regionMatches(0, str, 0, str.count);
237   }
238
239   public boolean startsWith(@LOC("in") String str, @LOC("in") int toffset) {
240     return regionMatches(toffset, str, 0, str.count);
241   }
242
243   public boolean regionMatches(@LOC("in") int toffset, @LOC("in") String other, @LOC("in") int ooffset, @LOC("in") int len) {
244     if (toffset<0 || ooffset <0 || (toffset+len)>count || (ooffset+len)>other.count)
245       return false;
246     for(int i=0; i<len; i++)
247       if (other.value[i+other.offset+ooffset]!=
248         this.value[i+this.offset+toffset])
249         return false;
250     return true;
251   }
252
253   public char[] toCharArray() {
254     @LOC("data") char str[]=new char[count];
255     for(@LOC("data") int i=0; i<count; i++)
256       str[i]=value[i+offset];
257     return str;
258   }
259
260   public byte[] getBytes() {
261     byte str[]=new byte[count];
262     for(int i=0; i<count; i++)
263       str[i]=(byte)value[i+offset];
264     return str;
265   }
266
267   public void getChars(@LOC("in") char dst[], @LOC("in") int dstBegin) {
268     getChars(0, count, dst, dstBegin);
269   }
270
271   public void getChars(@LOC("in") int srcBegin, @LOC("in") int srcEnd, @LOC("in") char dst[],@LOC("in")  int dstBegin) {
272     if((srcBegin < 0) || (srcEnd > count) || (srcBegin > srcEnd)) {
273       // FIXME
274       System.printString("Index error: "+srcBegin+" "+srcEnd+" "+count+"\n"+this);
275       System.exit(-1);
276     }
277     int len = srcEnd - srcBegin;
278     int j = dstBegin;
279     for(int i=srcBegin; i<srcEnd; i++)
280       dst[j++]=value[i+offset];
281     return;
282   }
283 */
284   public int length() {
285     return count;
286   }
287 /*
288   public char charAt(@LOC("in") int i) {
289     return value[i+offset];
290   }
291 */
292   public String toString() {
293     return this;
294   }
295
296   public static String valueOf(@LOC("in") Object o) {
297     @LOC("proc") String rValue;
298     if (o==null)
299       rValue="null";
300     else
301       rValue=o.toString();
302     return rValue;
303   }
304   
305   public static String valueOf(@LOC("in") int x) {
306     @LOC("in") int length=0;
307     @LOC("in") int tmp;
308     if (x<0)
309       tmp=-x;
310     else
311       tmp=x;
312     do {
313       tmp=tmp/10;
314       length=length+1;
315     } while(tmp!=0);
316
317     @LOC("in") char chararray[];
318     if (x<0)
319       chararray=new char[length+1];
320     else
321       chararray=new char[length];
322     @LOC("in") int voffset;
323     if (x<0) {
324       chararray[0]='-';
325       voffset=1;
326       x=-x;
327     } else
328       voffset=0;
329
330     do {
331       chararray[--length+voffset]=(char)(x%10+'0');
332       x=x/10;
333     } while (length!=0);
334     return new String(chararray);
335   }
336   
337 /*
338   public static String valueOf(@LOC("in") boolean b) {
339     if (b)
340       return new String("true");
341     else
342       return new String("false");
343   }
344
345   public static String valueOf(@LOC("in") char c) {
346     @LOC("data") char ar[]=new char[1];
347     ar[0]=c;
348     return new String(ar);
349   }
350
351   
352
353   public static String valueOf(@LOC("in") double val) {
354     char[] chararray=new char[20];
355     String s=new String();
356     s.offset=0;
357     s.count=convertdoubletochar(val, chararray);
358     s.value=chararray;
359     return s;
360   }
361
362   public static native int convertdoubletochar(double val, char [] chararray);
363
364   public static String valueOf(@LOC("in") long x) {
365     int length=0;
366     long tmp;
367     if (x<0)
368       tmp=-x;
369     else
370       tmp=x;
371     do {
372       tmp=tmp/10;
373       length=length+1;
374     } while(tmp!=0);
375
376     char chararray[];
377     if (x<0)
378       chararray=new char[length+1];
379     else
380       chararray=new char[length];
381     int voffset;
382     if (x<0) {
383       chararray[0]='-';
384       voffset=1;
385       x=-x;
386     } else
387       voffset=0;
388
389     do {
390       chararray[--length+voffset]=(char)(x%10+'0');
391       x=x/10;
392     } while (length!=0);
393     return new String(chararray);
394   }
395
396   public int compareTo(@LOC("in") String s) {
397     int smallerlength=count<s.count?count:s.count;
398
399     for( int i = 0; i < smallerlength; i++ ) {
400       int valDiff = this.charAt(i) - s.charAt(i);
401       if( valDiff != 0 ) {
402         return valDiff;
403       }
404     }
405     return count-s.count;
406   }
407 */
408   public int hashCode() {
409     if (cachedHashcode!=0)
410       return cachedHashcode;
411     @LOC("data") int hashcode=0;
412     for(@LOC("c") int i=0; i<count; i++)
413       hashcode=hashcode*31+value[i+offset];
414     cachedHashcode=hashcode;
415     return hashcode;
416   }
417
418   public boolean equals(@LOC("in") Object o) {
419     if (o.getType()!=getType())
420       return false;
421     @LOC("in") String s=(String)o;
422     if (s.count!=count)
423       return false;
424     for(@LOC("c") int i=0; i<count; i++) {
425       if (s.value[i+s.offset]!=value[i+offset])
426         return false;
427     }
428     return true;
429   }
430   /*
431   public boolean equalsIgnoreCase(@LOC("in") String s) {
432     if (s.count!=count)
433       return false;
434     for(int i=0; i<count; i++) {
435       char l=s.value[i+s.offset];
436       char r=value[i+offset];
437       if (l>='a'&&l<='z')
438         l=(char)((l-'a')+'A');
439       if (r>='a'&&r<='z')
440         r=(char)((r-'a')+'A');
441       if (l!=r)
442         return false;
443     }
444     return true;
445   }
446
447   public Vector split() {
448     Vector splitted = new Vector();
449     int i;
450     int cnt =0;
451
452     // skip first spaces
453     for(i = 0; i< count;i++) {
454       if(value[i+offset] != '\n' && value[i+offset] != '\t' && value[i+offset] != ' ') 
455           break;
456     }
457
458     int oldi=i;
459
460     while(i<count) {
461       if(value[i+offset] == '\n' || value[i+offset] == '\t' || value[i+offset] == ' ') {
462           String t=new String();
463           t.value=value;
464           t.offset=oldi;
465           t.count=i-oldi;
466           splitted.addElement(t);
467
468           // skip extra spaces
469           while( i < count && ( value[i+offset] == '\n' || value[i+offset] == '\t' || value[i+offset] == ' ')) {
470               i++;
471           }
472           oldi=i;
473       } else {
474           i++;
475       }
476     }
477
478     if(i!=oldi) {
479         String t=new String();
480         t.value=value;
481         t.offset=oldi;
482         t.count=i-oldi;
483         splitted.addElement(t);
484     }
485
486     return splitted;
487   }
488    
489   public boolean contains(@LOC("in") String str)
490   {
491     int i,j;
492     char[] strChar = str.toCharArray();
493     int cnt;
494
495     for(i = 0; i < count; i++) {
496       if(value[i] == strChar[0]) {
497         cnt=0;
498         for(j=0; j < str.length() && i+j < count;j++) {
499           if(value[i+j] == strChar[j])
500             cnt++;
501         }
502         if(cnt == str.length())
503           return true;
504       }
505     }
506
507     return false;
508
509   }
510
511   public String trim() {
512     int len = count;
513     int st = 0;
514     int off = offset;      //avoid getfield opcode 
515     char[] val = value;    // avoid getfield opcode 
516
517     while ((st < len) && (val[off + st] <= ' ')) {
518       st++;
519     }
520     while ((st < len) && (val[off + len - 1] <= ' ')) {
521       len--;
522     }
523     return ((st > 0) || (len < count)) ? substring(st, len) : this;
524   }
525
526   public boolean matches(@LOC("in") String regex) {
527     System.println("String.matches() is not fully supported");
528     return this.equals(regex);
529   }
530   */
531 }