Files @ r20718:cc912091a170
Branch filter:

Location: cpp/openttd-patchpack/source/src/string.cpp - annotation

translators
(svn r25756) -Update from WebTranslator v3.0:
indonesian - 2 changes by UseYourIllusion
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
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
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
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
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
r5584:545d748cc681
r5584:545d748cc681
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r12768:980ae0491352
r9111:983de9c5a848
r6420:01087f989fd1
r5584:545d748cc681
r7257:851d091043e4
r8130:bece2e5c7460
r10299:def8dff34f3b
r8214:9a3935f9ef4e
r20614:4513b7ad6147
r5584:545d748cc681
r8264:d493cb51fe8a
r8264:d493cb51fe8a
r5584:545d748cc681
r11363:6906c490a00e
r5584:545d748cc681
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r10300:566a7441c264
r14565:a2544520e96d
r14565:a2544520e96d
r14565:a2544520e96d
r10300:566a7441c264
r10300:566a7441c264
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10647:62911ec68e89
r5584:545d748cc681
r5584:545d748cc681
r10303:b1fc6ef039b1
r5584:545d748cc681
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r10647:62911ec68e89
r5584:545d748cc681
r5584:545d748cc681
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r10303:b1fc6ef039b1
r5584:545d748cc681
r10303:b1fc6ef039b1
r5584:545d748cc681
r17417:6d2ef4fd9984
r5584:545d748cc681
r17417:6d2ef4fd9984
r7257:851d091043e4
r17417:6d2ef4fd9984
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r17625:366001a31c88
r10299:def8dff34f3b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10299:def8dff34f3b
r5584:545d748cc681
r10299:def8dff34f3b
r10299:def8dff34f3b
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r18951:37daf10aa072
r5584:545d748cc681
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r18732:ad27548fd630
r17099:f140f6165f35
r18732:ad27548fd630
r5584:545d748cc681
r11272:411ffa5b815a
r11272:411ffa5b815a
r5584:545d748cc681
r15550:2de5a84a5b3b
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r5584:545d748cc681
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r11272:411ffa5b815a
r18951:37daf10aa072
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r18732:ad27548fd630
r10801:64b9bb8550d8
r5584:545d748cc681
r18732:ad27548fd630
r10801:64b9bb8550d8
r10801:64b9bb8550d8
r10801:64b9bb8550d8
r5584:545d748cc681
r5584:545d748cc681
r18732:ad27548fd630
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r17099:f140f6165f35
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r20531:6a7aeb0059d3
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r17099:f140f6165f35
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r16407:50e70180295c
r5584:545d748cc681
r17099:f140f6165f35
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15610:623a23fb6560
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r16663:6d591011eeb3
r15610:623a23fb6560
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6420:01087f989fd1
r15613:193c12018337
r17863:5b083a56ed26
r15613:193c12018337
r17863:5b083a56ed26
r5584:545d748cc681
r17863:5b083a56ed26
r17863:5b083a56ed26
r17863:5b083a56ed26
r17863:5b083a56ed26
r17863:5b083a56ed26
r17863:5b083a56ed26
r17863:5b083a56ed26
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r13401:29797ae8905d
r13401:29797ae8905d
r13401:29797ae8905d
r13401:29797ae8905d
r15067:d55116170d15
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8181:9da7946bf318
r8181:9da7946bf318
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r8181:9da7946bf318
r5584:545d748cc681
r5584:545d748cc681
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r5630:90e138facb22
r5584:545d748cc681
r5584:545d748cc681
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r19944:25a78576fb5e
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14566:6fc89b319eac
r14572:30796ddb265e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r10299:def8dff34f3b
r5584:545d748cc681
r15610:623a23fb6560
r15610:623a23fb6560
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r15613:193c12018337
r15613:193c12018337
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r10299:def8dff34f3b
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5634:5809aab23a85
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15372:aa5645595f2e
r15372:aa5645595f2e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r7928:a80e7e05d6c5
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11363:6906c490a00e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r15372:aa5645595f2e
r15372:aa5645595f2e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r11363:6906c490a00e
r5584:545d748cc681
r5584:545d748cc681
r5584:545d748cc681
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r18847:c72a2915657e
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6274:0d622d76ec4d
r6274:0d622d76ec4d
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6215:4a6af7c935ec
r6218:0fcab1d9c05b
r9997:8d5022aa8de7
r15230:2d72b40155e8
r9997:8d5022aa8de7
r9997:8d5022aa8de7
r20506:07e5ca943521
r9997:8d5022aa8de7
r9997:8d5022aa8de7
r9997:8d5022aa8de7
r9997:8d5022aa8de7
r15230:2d72b40155e8
r11031:34050e97c354
r11036:64a843b9f543
r14352:2d48e17549d1
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r14352:2d48e17549d1
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11031:34050e97c354
r11036:64a843b9f543
r16603:771c410131a7
r16603:771c410131a7
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r20026:a10eaf11a0ba
r16603:771c410131a7
r16603:771c410131a7
r20026:a10eaf11a0ba
r16603:771c410131a7
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r20026:a10eaf11a0ba
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r16603:771c410131a7
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20615:a9017d659ca9
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
r20614:4513b7ad6147
/* $Id$ */

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */

/** @file string.cpp Handling of C-type strings (char*). */

#include "stdafx.h"
#include "debug.h"
#include "core/alloc_func.hpp"
#include "core/math_func.hpp"
#include "string_func.h"
#include "string_base.h"

#include "table/control_codes.h"

#include <stdarg.h>
#include <ctype.h> /* required for tolower() */

#ifdef _MSC_VER
#include <errno.h> // required by vsnprintf implementation for MSVC
#endif

#ifdef WITH_ICU
/* Required by strnatcmp. */
#include <unicode/ustring.h>
#include "language.h"
#include "gfx_func.h"
#endif /* WITH_ICU */

/**
 * Safer implementation of vsnprintf; same as vsnprintf except:
 * - last instead of size, i.e. replace sizeof with lastof.
 * - return gives the amount of characters added, not what it would add.
 * @param str    buffer to write to up to last
 * @param last   last character we may write to
 * @param format the formatting (see snprintf)
 * @param ap     the list of arguments for the format
 * @return the number of added characters
 */
static int CDECL vseprintf(char *str, const char *last, const char *format, va_list ap)
{
	ptrdiff_t diff = last - str;
	if (diff < 0) return 0;
	return min((int)diff, vsnprintf(str, diff + 1, format, ap));
}

/**
 * Appends characters from one string to another.
 *
 * Appends the source string to the destination string with respect of the
 * terminating null-character and the maximum size of the destination
 * buffer.
 *
 * @note usage ttd_strlcat(dst, src, lengthof(dst));
 * @note lengthof() applies only to fixed size arrays
 *
 * @param dst The buffer containing the target string
 * @param src The buffer containing the string to append
 * @param size The maximum size of the destination buffer
 */
void ttd_strlcat(char *dst, const char *src, size_t size)
{
	assert(size > 0);
	while (size > 0 && *dst != '\0') {
		size--;
		dst++;
	}

	ttd_strlcpy(dst, src, size);
}


/**
 * Copies characters from one buffer to another.
 *
 * Copies the source string to the destination buffer with respect of the
 * terminating null-character and the maximum size of the destination
 * buffer.
 *
 * @note usage ttd_strlcpy(dst, src, lengthof(dst));
 * @note lengthof() applies only to fixed size arrays
 *
 * @param dst The destination buffer
 * @param src The buffer containing the string to copy
 * @param size The maximum size of the destination buffer
 */
void ttd_strlcpy(char *dst, const char *src, size_t size)
{
	assert(size > 0);
	while (--size > 0 && *src != '\0') {
		*dst++ = *src++;
	}
	*dst = '\0';
}


/**
 * Appends characters from one string to another.
 *
 * Appends the source string to the destination string with respect of the
 * terminating null-character and and the last pointer to the last element
 * in the destination buffer. If the last pointer is set to NULL no
 * boundary check is performed.
 *
 * @note usage: strecat(dst, src, lastof(dst));
 * @note lastof() applies only to fixed size arrays
 *
 * @param dst The buffer containing the target string
 * @param src The buffer containing the string to append
 * @param last The pointer to the last element of the destination buffer
 * @return The pointer to the terminating null-character in the destination buffer
 */
char *strecat(char *dst, const char *src, const char *last)
{
	assert(dst <= last);
	while (*dst != '\0') {
		if (dst == last) return dst;
		dst++;
	}

	return strecpy(dst, src, last);
}


/**
 * Copies characters from one buffer to another.
 *
 * Copies the source string to the destination buffer with respect of the
 * terminating null-character and the last pointer to the last element in
 * the destination buffer. If the last pointer is set to NULL no boundary
 * check is performed.
 *
 * @note usage: strecpy(dst, src, lastof(dst));
 * @note lastof() applies only to fixed size arrays
 *
 * @param dst The destination buffer
 * @param src The buffer containing the string to copy
 * @param last The pointer to the last element of the destination buffer
 * @return The pointer to the terminating null-character in the destination buffer
 */
char *strecpy(char *dst, const char *src, const char *last)
{
	assert(dst <= last);
	while (dst != last && *src != '\0') {
		*dst++ = *src++;
	}
	*dst = '\0';

	if (dst == last && *src != '\0') {
#if defined(STRGEN) || defined(SETTINGSGEN)
		error("String too long for destination buffer");
#else /* STRGEN || SETTINGSGEN */
		DEBUG(misc, 0, "String too long for destination buffer");
#endif /* STRGEN || SETTINGSGEN */
	}
	return dst;
}

/**
 * Format, "printf", into a newly allocated string.
 * @param str The formatting string.
 * @return The formatted string. You must free this!
 */
char *CDECL str_fmt(const char *str, ...)
{
	char buf[4096];
	va_list va;

	va_start(va, str);
	int len = vseprintf(buf, lastof(buf), str, va);
	va_end(va);
	char *p = MallocT<char>(len + 1);
	memcpy(p, buf, len + 1);
	return p;
}

/**
 * Scan the string for old values of SCC_ENCODED and fix it to
 * it's new, static value.
 * @param str the string to scan
 * @param last the last valid character of str
 */
void str_fix_scc_encoded(char *str, const char *last)
{
	while (str <= last && *str != '\0') {
		size_t len = Utf8EncodedCharLen(*str);
		if ((len == 0 && str + 4 > last) || str + len > last) break;

		WChar c;
		len = Utf8Decode(&c, str);
		if (c == '\0') break;

		if (c == 0xE028 || c == 0xE02A) {
			c = SCC_ENCODED;
		}
		str += Utf8Encode(str, c);
	}
	*str = '\0';
}


/**
 * Scans the string for valid characters and if it finds invalid ones,
 * replaces them with a question mark '?' (if not ignored)
 * @param str the string to validate
 * @param last the last valid character of str
 * @param settings the settings for the string validation.
 */
void str_validate(char *str, const char *last, StringValidationSettings settings)
{
	/* Assume the ABSOLUTE WORST to be in str as it comes from the outside. */

	char *dst = str;
	while (str <= last && *str != '\0') {
		size_t len = Utf8EncodedCharLen(*str);
		/* If the character is unknown, i.e. encoded length is 0
		 * we assume worst case for the length check.
		 * The length check is needed to prevent Utf8Decode to read
		 * over the terminating '\0' if that happens to be placed
		 * within the encoding of an UTF8 character. */
		if ((len == 0 && str + 4 > last) || str + len > last) break;

		WChar c;
		len = Utf8Decode(&c, str);
		/* It's possible to encode the string termination character
		 * into a multiple bytes. This prevents those termination
		 * characters to be skipped */
		if (c == '\0') break;

		if ((IsPrintable(c) && (c < SCC_SPRITE_START || c > SCC_SPRITE_END)) || ((settings & SVS_ALLOW_CONTROL_CODE) != 0 && c == SCC_ENCODED)) {
			/* Copy the character back. Even if dst is current the same as str
			 * (i.e. no characters have been changed) this is quicker than
			 * moving the pointers ahead by len */
			do {
				*dst++ = *str++;
			} while (--len != 0);
		} else if ((settings & SVS_ALLOW_NEWLINE) != 0  && c == '\n') {
			*dst++ = *str++;
		} else {
			if ((settings & SVS_ALLOW_NEWLINE) != 0 && c == '\r' && str[1] == '\n') {
				str += len;
				continue;
			}
			/* Replace the undesirable character with a question mark */
			str += len;
			if ((settings & SVS_REPLACE_WITH_QUESTION_MARK) != 0) *dst++ = '?';
		}
	}

	*dst = '\0';
}

/**
 * Scans the string for valid characters and if it finds invalid ones,
 * replaces them with a question mark '?'.
 * @param str the string to validate
 */
void ValidateString(const char *str)
{
	/* We know it is '\0' terminated. */
	str_validate(const_cast<char *>(str), str + strlen(str) + 1);
}


/**
 * Checks whether the given string is valid, i.e. contains only
 * valid (printable) characters and is properly terminated.
 * @param str  The string to validate.
 * @param last The last character of the string, i.e. the string
 *             must be terminated here or earlier.
 */
bool StrValid(const char *str, const char *last)
{
	/* Assume the ABSOLUTE WORST to be in str as it comes from the outside. */

	while (str <= last && *str != '\0') {
		size_t len = Utf8EncodedCharLen(*str);
		/* Encoded length is 0 if the character isn't known.
		 * The length check is needed to prevent Utf8Decode to read
		 * over the terminating '\0' if that happens to be placed
		 * within the encoding of an UTF8 character. */
		if (len == 0 || str + len > last) return false;

		WChar c;
		len = Utf8Decode(&c, str);
		if (!IsPrintable(c) || (c >= SCC_SPRITE_START && c <= SCC_SPRITE_END)) {
			return false;
		}

		str += len;
	}

	return *str == '\0';
}

/** Scans the string for colour codes and strips them */
void str_strip_colours(char *str)
{
	char *dst = str;
	WChar c;
	size_t len;

	for (len = Utf8Decode(&c, str); c != '\0'; len = Utf8Decode(&c, str)) {
		if (c < SCC_BLUE || c > SCC_BLACK) {
			/* Copy the character back. Even if dst is current the same as str
			 * (i.e. no characters have been changed) this is quicker than
			 * moving the pointers ahead by len */
			do {
				*dst++ = *str++;
			} while (--len != 0);
		} else {
			/* Just skip (strip) the colour codes */
			str += len;
		}
	}
	*dst = '\0';
}

/**
 * Get the length of an UTF-8 encoded string in number of characters
 * and thus not the number of bytes that the encoded string contains.
 * @param s The string to get the length for.
 * @return The length of the string in characters.
 */
size_t Utf8StringLength(const char *s)
{
	size_t len = 0;
	const char *t = s;
	while (Utf8Consume(&t) != 0) len++;
	return len;
}


/**
 * Convert a given ASCII string to lowercase.
 * NOTE: only support ASCII characters, no UTF8 fancy. As currently
 * the function is only used to lowercase data-filenames if they are
 * not found, this is sufficient. If more, or general functionality is
 * needed, look to r7271 where it was removed because it was broken when
 * using certain locales: eg in Turkish the uppercase 'I' was converted to
 * '?', so just revert to the old functionality
 * @param str string to convert
 * @return String has changed.
 */
bool strtolower(char *str)
{
	bool changed = false;
	for (; *str != '\0'; str++) {
		char new_str = tolower(*str);
		changed |= new_str != *str;
		*str = new_str;
	}
	return changed;
}

/**
 * Only allow certain keys. You can define the filter to be used. This makes
 *  sure no invalid keys can get into an editbox, like BELL.
 * @param key character to be checked
 * @param afilter the filter to use
 * @return true or false depending if the character is printable/valid or not
 */
bool IsValidChar(WChar key, CharSetFilter afilter)
{
	switch (afilter) {
		case CS_ALPHANUMERAL:  return IsPrintable(key);
		case CS_NUMERAL:       return (key >= '0' && key <= '9');
		case CS_NUMERAL_SPACE: return (key >= '0' && key <= '9') || key == ' ';
		case CS_ALPHA:         return IsPrintable(key) && !(key >= '0' && key <= '9');
		case CS_HEXADECIMAL:   return (key >= '0' && key <= '9') || (key >= 'a' && key <= 'f') || (key >= 'A' && key <= 'F');
	}

	return false;
}

#ifdef WIN32
/* Since version 3.14, MinGW Runtime has snprintf() and vsnprintf() conform to C99 but it's not the case for older versions */
#if (__MINGW32_MAJOR_VERSION < 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION < 14))
int CDECL snprintf(char *str, size_t size, const char *format, ...)
{
	va_list ap;
	int ret;

	va_start(ap, format);
	ret = vsnprintf(str, size, format, ap);
	va_end(ap);
	return ret;
}
#endif /* MinGW Runtime < 3.14 */

#ifdef _MSC_VER
/**
 * Almost POSIX compliant implementation of \c vsnprintf for VC compiler.
 * The difference is in the value returned on output truncation. This
 * implementation returns size whereas a POSIX implementation returns
 * size or more (the number of bytes that would be written to str
 * had size been sufficiently large excluding the terminating null byte).
 */
int CDECL vsnprintf(char *str, size_t size, const char *format, va_list ap)
{
	if (size == 0) return 0;

	errno = 0;
	int ret = _vsnprintf(str, size, format, ap);

	if (ret < 0) {
		if (errno != ERANGE) {
			/* There's a formatting error, better get that looked
			 * at properly instead of ignoring it. */
			NOT_REACHED();
		}
	} else if ((size_t)ret < size) {
		/* The buffer is big enough for the number of
		 * characters stored (excluding null), i.e.
		 * the string has been null-terminated. */
		return ret;
	}

	/* The buffer is too small for _vsnprintf to write the
	 * null-terminator at its end and return size. */
	str[size - 1] = '\0';
	return (int)size;
}
#endif /* _MSC_VER */

#endif /* WIN32 */

/**
 * Safer implementation of snprintf; same as snprintf except:
 * - last instead of size, i.e. replace sizeof with lastof.
 * - return gives the amount of characters added, not what it would add.
 * @param str    buffer to write to up to last
 * @param last   last character we may write to
 * @param format the formatting (see snprintf)
 * @return the number of added characters
 */
int CDECL seprintf(char *str, const char *last, const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	int ret = vseprintf(str, last, format, ap);
	va_end(ap);
	return ret;
}


/**
 * Convert the md5sum to a hexadecimal string representation
 * @param buf buffer to put the md5sum into
 * @param last last character of buffer (usually lastof(buf))
 * @param md5sum the md5sum itself
 * @return a pointer to the next character after the md5sum
 */
char *md5sumToString(char *buf, const char *last, const uint8 md5sum[16])
{
	char *p = buf;

	for (uint i = 0; i < 16; i++) {
		p += seprintf(p, last, "%02X", md5sum[i]);
	}

	return p;
}


/* UTF-8 handling routines */


/**
 * Decode and consume the next UTF-8 encoded character.
 * @param c Buffer to place decoded character.
 * @param s Character stream to retrieve character from.
 * @return Number of characters in the sequence.
 */
size_t Utf8Decode(WChar *c, const char *s)
{
	assert(c != NULL);

	if (!HasBit(s[0], 7)) {
		/* Single byte character: 0xxxxxxx */
		*c = s[0];
		return 1;
	} else if (GB(s[0], 5, 3) == 6) {
		if (IsUtf8Part(s[1])) {
			/* Double byte character: 110xxxxx 10xxxxxx */
			*c = GB(s[0], 0, 5) << 6 | GB(s[1], 0, 6);
			if (*c >= 0x80) return 2;
		}
	} else if (GB(s[0], 4, 4) == 14) {
		if (IsUtf8Part(s[1]) && IsUtf8Part(s[2])) {
			/* Triple byte character: 1110xxxx 10xxxxxx 10xxxxxx */
			*c = GB(s[0], 0, 4) << 12 | GB(s[1], 0, 6) << 6 | GB(s[2], 0, 6);
			if (*c >= 0x800) return 3;
		}
	} else if (GB(s[0], 3, 5) == 30) {
		if (IsUtf8Part(s[1]) && IsUtf8Part(s[2]) && IsUtf8Part(s[3])) {
			/* 4 byte character: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
			*c = GB(s[0], 0, 3) << 18 | GB(s[1], 0, 6) << 12 | GB(s[2], 0, 6) << 6 | GB(s[3], 0, 6);
			if (*c >= 0x10000 && *c <= 0x10FFFF) return 4;
		}
	}

	/* DEBUG(misc, 1, "[utf8] invalid UTF-8 sequence"); */
	*c = '?';
	return 1;
}


/**
 * Encode a unicode character and place it in the buffer.
 * @param buf Buffer to place character.
 * @param c   Unicode character to encode.
 * @return Number of characters in the encoded sequence.
 */
size_t Utf8Encode(char *buf, WChar c)
{
	if (c < 0x80) {
		*buf = c;
		return 1;
	} else if (c < 0x800) {
		*buf++ = 0xC0 + GB(c,  6, 5);
		*buf   = 0x80 + GB(c,  0, 6);
		return 2;
	} else if (c < 0x10000) {
		*buf++ = 0xE0 + GB(c, 12, 4);
		*buf++ = 0x80 + GB(c,  6, 6);
		*buf   = 0x80 + GB(c,  0, 6);
		return 3;
	} else if (c < 0x110000) {
		*buf++ = 0xF0 + GB(c, 18, 3);
		*buf++ = 0x80 + GB(c, 12, 6);
		*buf++ = 0x80 + GB(c,  6, 6);
		*buf   = 0x80 + GB(c,  0, 6);
		return 4;
	}

	/* DEBUG(misc, 1, "[utf8] can't UTF-8 encode value 0x%X", c); */
	*buf = '?';
	return 1;
}

/**
 * Properly terminate an UTF8 string to some maximum length
 * @param s string to check if it needs additional trimming
 * @param maxlen the maximum length the buffer can have.
 * @return the new length in bytes of the string (eg. strlen(new_string))
 * @note maxlen is the string length _INCLUDING_ the terminating '\0'
 */
size_t Utf8TrimString(char *s, size_t maxlen)
{
	size_t length = 0;

	for (const char *ptr = strchr(s, '\0'); *s != '\0';) {
		size_t len = Utf8EncodedCharLen(*s);
		/* Silently ignore invalid UTF8 sequences, our only concern trimming */
		if (len == 0) len = 1;

		/* Take care when a hard cutoff was made for the string and
		 * the last UTF8 sequence is invalid */
		if (length + len >= maxlen || (s + len > ptr)) break;
		s += len;
		length += len;
	}

	*s = '\0';
	return length;
}

#ifdef DEFINE_STRNDUP
char *strndup(const char *s, size_t len)
{
	len = ttd_strnlen(s, len);
	char *tmp = CallocT<char>(len + 1);
	memcpy(tmp, s, len);
	return tmp;
}
#endif /* DEFINE_STRNDUP */

#ifdef DEFINE_STRCASESTR
char *strcasestr(const char *haystack, const char *needle)
{
	size_t hay_len = strlen(haystack);
	size_t needle_len = strlen(needle);
	while (hay_len >= needle_len) {
		if (strncasecmp(haystack, needle, needle_len) == 0) return const_cast<char *>(haystack);

		haystack++;
		hay_len--;
	}

	return NULL;
}
#endif /* DEFINE_STRCASESTR */

/**
 * Skip some of the 'garbage' in the string that we don't want to use
 * to sort on. This way the alphabetical sorting will work better as
 * we would be actually using those characters instead of some other
 * characters such as spaces and tildes at the begin of the name.
 * @param str The string to skip the initial garbage of.
 * @return The string with the garbage skipped.
 */
static const char *SkipGarbage(const char *str)
{
	while (*str != '\0' && (*str < 'A' || IsInsideMM(*str, '[', '`' + 1) || IsInsideMM(*str, '{', '~' + 1))) str++;
	return str;
}

/**
 * Compares two strings using case insensitive natural sort.
 *
 * @param s1 First string to compare.
 * @param s2 Second string to compare.
 * @param ignore_garbage_at_front Skip punctuation characters in the front
 * @return Less than zero if s1 < s2, zero if s1 == s2, greater than zero if s1 > s2.
 */
int strnatcmp(const char *s1, const char *s2, bool ignore_garbage_at_front)
{
	if (ignore_garbage_at_front) {
		s1 = SkipGarbage(s1);
		s2 = SkipGarbage(s2);
	}
#ifdef WITH_ICU
	if (_current_collator != NULL) {
		UErrorCode status = U_ZERO_ERROR;
		int result;

		/* We want to use the new faster method for ICU 4.2 and higher. */
#if U_ICU_VERSION_MAJOR_NUM > 4 || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM >= 2)
		/* The StringPiece parameter gets implicitly constructed from the char *. */
		result = _current_collator->compareUTF8(s1, s2, status);
#else /* The following for 4.0 and lower. */
		UChar buffer1[DRAW_STRING_BUFFER];
		u_strFromUTF8Lenient(buffer1, lengthof(buffer1), NULL, s1, -1, &status);
		UChar buffer2[DRAW_STRING_BUFFER];
		u_strFromUTF8Lenient(buffer2, lengthof(buffer2), NULL, s2, -1, &status);

		result = _current_collator->compare(buffer1, buffer2, status);
#endif /* ICU version check. */
		if (U_SUCCESS(status)) return result;
	}

#endif /* WITH_ICU */

	/* Do a normal comparison if ICU is missing or if we cannot create a collator. */
	return strcasecmp(s1, s2);
}

#ifdef WITH_ICU

#include <unicode/utext.h>
#include <unicode/brkiter.h>

/** String iterator using ICU as a backend. */
class IcuStringIterator : public StringIterator
{
	icu::BreakIterator *char_itr; ///< ICU iterator for characters.
	icu::BreakIterator *word_itr; ///< ICU iterator for words.
	const char *string;           ///< Iteration string in UTF-8.

	SmallVector<UChar, 32> utf16_str;      ///< UTF-16 copy of the string.
	SmallVector<size_t, 32> utf16_to_utf8; ///< Mapping from UTF-16 code point position to index in the UTF-8 source string.

public:
	IcuStringIterator() : char_itr(NULL), word_itr(NULL)
	{
		UErrorCode status = U_ZERO_ERROR;
		this->char_itr = icu::BreakIterator::createCharacterInstance(icu::Locale(_current_language != NULL ? _current_language->isocode : "en"), status);
		this->word_itr = icu::BreakIterator::createWordInstance(icu::Locale(_current_language != NULL ? _current_language->isocode : "en"), status);

		*this->utf16_str.Append() = '\0';
		*this->utf16_to_utf8.Append() = 0;
	}

	virtual ~IcuStringIterator()
	{
		delete this->char_itr;
		delete this->word_itr;
	}

	virtual void SetString(const char *s)
	{
		this->string = s;

		/* Unfortunately current ICU versions only provide rudimentary support
		 * for word break iterators (especially for CJK languages) in combination
		 * with UTF-8 input. As a work around we have to convert the input to
		 * UTF-16 and create a mapping back to UTF-8 character indices. */
		this->utf16_str.Clear();
		this->utf16_to_utf8.Clear();

		while (*s != '\0') {
			size_t idx = s - this->string;

			WChar c = Utf8Consume(&s);
			if (c <	0x10000) {
				*this->utf16_str.Append() = (UChar)c;
			} else {
				/* Make a surrogate pair. */
				*this->utf16_str.Append() = (UChar)(0xD800 + ((c - 0x10000) >> 10));
				*this->utf16_str.Append() = (UChar)(0xDC00 + ((c - 0x10000) & 0x3FF));
				*this->utf16_to_utf8.Append() = idx;
			}
			*this->utf16_to_utf8.Append() = idx;
		}
		*this->utf16_str.Append() = '\0';
		*this->utf16_to_utf8.Append() = s - this->string;

		UText text = UTEXT_INITIALIZER;
		UErrorCode status = U_ZERO_ERROR;
		utext_openUChars(&text, this->utf16_str.Begin(), this->utf16_str.Length() - 1, &status);
		this->char_itr->setText(&text, status);
		this->word_itr->setText(&text, status);
		this->char_itr->first();
		this->word_itr->first();
	}

	virtual size_t SetCurPosition(size_t pos)
	{
		/* Convert incoming position to an UTF-16 string index. */
		uint utf16_pos = 0;
		for (uint i = 0; i < this->utf16_to_utf8.Length(); i++) {
			if (this->utf16_to_utf8[i] == pos) {
				utf16_pos = i;
				break;
			}
		}

		/* isBoundary has the documented side-effect of setting the current
		 * position to the first valid boundary equal to or greater than
		 * the passed value. */
		this->char_itr->isBoundary(utf16_pos);
		return this->utf16_to_utf8[this->char_itr->current()];
	}

	virtual size_t Next(IterType what)
	{
		int32_t pos;
		switch (what) {
			case ITER_CHARACTER:
				pos = this->char_itr->next();
				break;

			case ITER_WORD:
				pos = this->word_itr->following(this->char_itr->current());
				/* The ICU word iterator considers both the start and the end of a word a valid
				 * break point, but we only want word starts. Move to the next location in
				 * case the new position points to whitespace. */
				while (pos != icu::BreakIterator::DONE && IsWhitespace(Utf16DecodeChar((const uint16 *)&this->utf16_str[pos]))) pos = this->word_itr->next();

				this->char_itr->isBoundary(pos);
				break;

			default:
				NOT_REACHED();
		}

		return pos == icu::BreakIterator::DONE ? END : this->utf16_to_utf8[pos];
	}

	virtual size_t Prev(IterType what)
	{
		int32_t pos;
		switch (what) {
			case ITER_CHARACTER:
				pos = this->char_itr->previous();
				break;

			case ITER_WORD:
				pos = this->word_itr->preceding(this->char_itr->current());
				/* The ICU word iterator considers both the start and the end of a word a valid
				 * break point, but we only want word starts. Move to the previous location in
				 * case the new position points to whitespace. */
				while (pos != icu::BreakIterator::DONE && IsWhitespace(Utf16DecodeChar((const uint16 *)&this->utf16_str[pos]))) pos = this->word_itr->previous();

				this->char_itr->isBoundary(pos);
				break;

			default:
				NOT_REACHED();
		}

		return pos == icu::BreakIterator::DONE ? END : this->utf16_to_utf8[pos];
	}
};

/* static */ StringIterator *StringIterator::Create()
{
	return new IcuStringIterator();
}

#else

/** Fallback simple string iterator. */
class DefaultStringIterator : public StringIterator
{
	const char *string; ///< Current string.
	size_t len;         ///< String length.
	size_t cur_pos;     ///< Current iteration position.

public:
	DefaultStringIterator() : string(NULL)
	{
	}

	virtual void SetString(const char *s)
	{
		this->string = s;
		this->len = strlen(s);
		this->cur_pos = 0;
	}

	virtual size_t SetCurPosition(size_t pos)
	{
		assert(this->string != NULL && pos <= this->len);
		/* Sanitize in case we get a position inside an UTF-8 sequence. */
		while (pos > 0 && IsUtf8Part(this->string[pos])) pos--;
		return this->cur_pos = pos;
	}

	virtual size_t Next(IterType what)
	{
		assert(this->string != NULL);

		/* Already at the end? */
		if (this->cur_pos >= this->len) return END;

		switch (what) {
			case ITER_CHARACTER: {
				WChar c;
				this->cur_pos += Utf8Decode(&c, this->string + this->cur_pos);
				return this->cur_pos;
			}

			case ITER_WORD: {
				WChar c;
				/* Consume current word. */
				size_t offs = Utf8Decode(&c, this->string + this->cur_pos);
				while (this->cur_pos < this->len && !IsWhitespace(c)) {
					this->cur_pos += offs;
					offs = Utf8Decode(&c, this->string + this->cur_pos);
				}
				/* Consume whitespace to the next word. */
				while (this->cur_pos < this->len && IsWhitespace(c)) {
					this->cur_pos += offs;
					offs = Utf8Decode(&c, this->string + this->cur_pos);
				}

				return this->cur_pos;
			}

			default:
				NOT_REACHED();
		}

		return END;
	}

	virtual size_t Prev(IterType what)
	{
		assert(this->string != NULL);

		/* Already at the beginning? */
		if (this->cur_pos == 0) return END;

		switch (what) {
			case ITER_CHARACTER:
				return this->cur_pos = Utf8PrevChar(this->string + this->cur_pos) - this->string;

			case ITER_WORD: {
				const char *s = this->string + this->cur_pos;
				WChar c;
				/* Consume preceding whitespace. */
				do {
					s = Utf8PrevChar(s);
					Utf8Decode(&c, s);
				} while (s > this->string && IsWhitespace(c));
				/* Consume preceding word. */
				while (s > this->string && !IsWhitespace(c)) {
					s = Utf8PrevChar(s);
					Utf8Decode(&c, s);
				}
				/* Move caret back to the beginning of the word. */
				if (IsWhitespace(c)) Utf8Consume(&s);

				return this->cur_pos = s - this->string;
			}

			default:
				NOT_REACHED();
		}

		return END;
	}
};

/* static */ StringIterator *StringIterator::Create()
{
	return new DefaultStringIterator();
}

#endif