Permalink
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Feb 10, 2018
Mar 19, 2018
Jan 14, 2015
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Jan 14, 2015
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Jan 14, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Feb 9, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Dec 3, 2015
Dec 3, 2015
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Dec 28, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jun 29, 2017
Mar 19, 2018
Jun 29, 2017
Mar 19, 2018
Jun 29, 2017
Jun 29, 2017
Jul 10, 2017
Mar 19, 2018
Jul 10, 2017
Mar 19, 2018
Mar 19, 2018
Jun 29, 2017
Newer
100644
2033 lines (1865 sloc)
64.7 KB
6
// Polyfill for older browsers
7
// The code does not use a regex to make it a bit faster.
8
// Implementation taken from a comment by Timo on the blog:
9
// http://blog.stevenlevithan.com/archives/faster-trim-javascript
10
String.prototype.trim = function () {
11
var c
12
for(var i = 0; i < this.length; i++){
13
c = this.charCodeAt(i)
14
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
15
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
16
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
17
continue
18
}else{break}
19
}
20
for(var j = this.length - 1; j >= i; j--){
21
c = this.charCodeAt(j)
22
if ([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
23
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
24
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
25
continue
26
}else{break}
27
}
28
return this.substring(i, j + 1);
29
}
30
}
31
if (!String.prototype.trimLeft) {
32
// Convenience method for browsers which do not have a native trimLeft
33
// (which is a nonstandard extension in Firefox and Chrome)
34
String.prototype.trimLeft = function () {
35
var c
36
for(var i = 0; i < this.length; i++){
37
c = this.charCodeAt(i)
38
if ([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
39
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
40
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
41
continue
42
}else{break}
43
}
44
return this.substring(i)
48
String.prototype.trimRight = function () {
49
// Convenience method for browsers which do not have a native trimRight
50
// (which is a nonstandard extension in Firefox and Chrome)
51
var c
52
for(var j = this.length - 1; j >= 0; j--){
53
c = this.charCodeAt(j)
54
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
55
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
56
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
57
continue
58
}else{break}
59
}
60
return this.substring(0, j + 1)
75
if($.start === null || $.start === _b_.None){$.start = 0}
76
else if($.start < 0){
77
$.start += $.self.length
78
$.start = Math.max(0, $.start)
79
}
80
if($.end === null || $.end === _b_.None){$.end = $.self.length}
81
else if($.end < 0){
82
$.end += $.self.length
83
$.end = Math.max(0, $.end)
84
}
86
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
87
throw _b_.TypeError.$factory("slice indices must be integers " +
88
"or None or have an __index__ method")
89
}
99
if(! _b_.isinstance(obj, str)){
100
throw _b_.TypeError.$factory("can't convert '"+
101
$B.get_class(obj).__name__+"' object to str implicitely")
102
}
106
if(!(typeof other === "string")){
107
try{return getattr(other, "__radd__")(self)}
108
catch(err){
109
throw _b_.TypeError.$factory("Can't convert " +
110
$B.get_class(other).__name__ + " to str implicitely")}
115
str.__contains__ = function(self, item){
116
if(!(typeof item == "string")){
117
throw _b_.TypeError.$factory("'in <string>' requires " +
118
"string as left operand, not " + item.__class__)
119
}
121
if(nbcar == 0) {return true} // a string contains the empty string
122
if(self.length == 0){return nbcar == 0}
123
for(var i = 0, len = self.length; i < len; i++){
124
if(self.substr(i, nbcar) == item){return true}
133
// __dir__must be assigned explicitely because attribute resolution for
134
// builtin classes doesn't use __mro__
138
if(other === undefined){ // compare object "self" to class "str"
139
return self === str
141
if (_b_.isinstance(other, _b_.str)) {
142
return other.valueOf() == self.valueOf()
143
}
149
if(fmt.type && fmt.type != "s"){
150
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
158
if(fmt.sign !== undefined){
159
throw _b_.ValueError.$factory(
160
"Sign not allowed in string format specifier")
170
if(arg < 0) {pos += self.length}
171
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
172
throw _b_.IndexError.$factory("string index out of range")
173
}
174
if(isinstance(arg, slice)) {
175
var s = _b_.slice.$conv_for_seq(arg, self.length),
176
start = s.start,
177
stop = s.stop,
178
step = s.step
179
var res = "",
181
if(step > 0){
182
if(stop <= start){return ""}
183
for(var i = start; i < stop; i += step){res += self.charAt(i)}
185
if(stop >= start){return ''}
186
for(var i = start; i > stop; i += step){res += self.charAt(i)}
190
if(isinstance(arg, bool)){return self.__getitem__(_b_.int.$factory(arg))}
191
throw _b_.TypeError.$factory("string indices must be integers")
196
return str.__hashvalue__ || $B.$py_next_hash-- // for hash of string type (not instance of string)
199
//http://stackoverflow.com/questions/2909106/python-whats-a-correct-and-good-way-to-implement-hash
200
// this implementation for strings maybe good enough for us..
201
218
var items = self.split("") // list of all characters in string
219
return $B.$iterator(items, $str_iterator)
246
return s
247
}
248
s = s.toString()
249
padding = parseInt(padding, 10)
250
if (minus_one) { // numeric formatting where sign goes in front of padding
251
padding -= 1
252
}
256
// left adjusted
257
return s + get_char_array(padding - s.length, flags.pad_char)
258
}
259
}
260
268
if(val.__class__ === $B.long_int){
269
s = $B.long_int.to_base(val, 10)
270
}else{
271
s = val.toString()
273
if(s[0] === "-"){
274
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
285
if(val === Infinity){
286
val = "inf"
287
}else if(val === -Infinity){
288
val = "-inf"
289
}else{
290
val = "nan"
312
var str_format = function(val, flags) {
313
// string format supports left and right padding
314
flags.pad_char = " " // even if 0 padding is defined, don't use it
320
if(val.__class__ === $B.long_int){
321
val = $B.long_int.to_base(val, 10)
322
}else{
323
val = parseInt(val)
341
var repr_format = function(val, flags) {
342
flags.pad_char = " " // even if 0 padding is defined, don't use it
343
return format_padding(repr(val), flags)
344
}
346
var ascii_format = function(val, flags) {
347
flags.pad_char = " " // even if 0 padding is defined, don't use it
348
return format_padding(ascii(val), flags)
349
}
361
flags.precision = parseInt(flags.precision, 10)
362
validate_precision(flags.precision)
363
}
364
return parseFloat(val)
365
}
368
var trailing_zeros = /(.*?)(0+)([eE].*)/,
369
leading_zeros = /\.(0*)/,
370
trailing_dot = /\.$/
372
var validate_precision = function(precision) {
373
// force precision to limits of javascript
378
var floating_point_format = function(val, upper, flags){
379
val = _float_helper(val, flags),
380
v = val.toString(),
381
v_len = v.length,
382
dot_idx = v.indexOf('.')
383
if(dot_idx < 0){dot_idx = v_len}
384
if(val < 1 && val > -1){
385
var zeros = leading_zeros.exec(v),
386
numzeros
387
if(zeros){
392
if(numzeros >= 4){
393
val = format_sign(val, flags) + format_float_precision(val, upper,
394
flags, _floating_g_exp_helper)
395
if(!flags.alternate){
408
return format_padding(format_sign(val, flags) +
409
format_float_precision(val, upper, flags,
410
function(val, precision) {
411
return val.toFixed(min(precision, v_len - dot_idx) +
412
numzeros)
413
}),
414
flags
415
)
416
}
417
418
if(dot_idx > flags.precision){
419
val = format_sign(val, flags) + format_float_precision(val, upper,
420
flags, _floating_g_exp_helper)
421
if(! flags.alternate){
433
return format_padding(format_sign(val, flags) +
434
format_float_precision(val, upper, flags,
435
function(val, precision) {
436
if(!flags.decimal_point){
437
precision = min(v_len - 1, 6)
438
}else if (precision > v_len){
439
if(! flags.alternate){
440
precision = v_len
441
}
443
if(precision < dot_idx){
444
precision = dot_idx
445
}
446
return val.toFixed(precision - dot_idx)
447
}),
448
flags
449
)
452
var _floating_g_exp_helper = function(val, precision, flags, upper){
453
if(precision){--precision}
456
var e_idx = val.lastIndexOf("e")
457
if(e_idx > val.length - 4){
458
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
461
return val
462
}
463
464
// fF
465
var floating_point_decimal_format = function(val, upper, flags) {
466
val = _float_helper(val, flags)
467
return format_padding(format_sign(val, flags) +
468
format_float_precision(val, upper, flags,
469
function(val, precision, flags) {
470
val = val.toFixed(precision)
471
if(precision === 0 && flags.alternate){
472
val += '.'
473
}
474
return val
475
}),
476
flags
477
)
478
}
479
480
var _floating_exp_helper = function(val, precision, flags, upper) {
481
val = val.toExponential(precision)
482
// pad exponent to two digits
495
return format_padding(format_sign(val, flags) +
496
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
503
if (val.__class__ === $B.long_int){
504
ret = $B.long_int.to_base(val, 16)
505
}else{
510
if(upper){ret = ret.toUpperCase()}
511
if (flags.pad_char === "0") {
512
if(val < 0){
522
if(flags.alternate){
523
if(ret.charAt(0) === "-"){
524
if(upper){ret = "-0X" + ret.slice(1)}
525
else{ret = "-0x" + ret.slice(1)}
526
}else{
527
if(upper){ret = "0X" + ret}
528
else{ret = "0x" + ret}
538
if(val.__class__ === $B.long_int){
539
ret = $B.long_int.to_base(8)
540
}else{
541
ret = parseInt(val)
542
ret = ret.toString(8)
558
if(flags.alternate){
559
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
560
else{ret = "0o" + ret}
565
var single_char_format = function(val, flags){
566
if(isinstance(val, str) && val.length == 1) return val
567
try{
575
var num_flag = function(c, flags){
576
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
577
flags.pad_char = "0"
583
flags.precision = (flags.precision || "") + c
584
}
585
}
586
587
var decimal_point_flag = function(val, flags) {
588
if (flags.decimal_point) {
589
// can only have one decimal point
590
throw new UnsupportedChar()
591
}
592
flags.decimal_point = true
593
}
594
595
var neg_flag = function(val, flags){
596
flags.pad_char = " " // overrides '0' flag
613
"s": str_format,
614
"d": num_format,
615
"i": num_format,
616
"u": num_format,
617
"o": octal_format,
618
"r": repr_format,
619
"a": ascii_format,
620
"g": function(val, flags){
621
return floating_point_format(val, false, flags)
622
},
623
"G": function(val, flags){return floating_point_format(val, true, flags)},
624
"f": function(val, flags){
625
return floating_point_decimal_format(val, false, flags)
626
},
627
"F": function(val, flags){
628
return floating_point_decimal_format(val, true, flags)
629
},
630
"e": function(val, flags){
631
return floating_point_exponential_format(val, false, flags)
632
},
633
"E": function(val, flags){
634
return floating_point_exponential_format(val, true, flags)
635
},
636
"x": function(val, flags){return signed_hex_format(val, false, flags)},
637
"X": function(val, flags){return signed_hex_format(val, true, flags)},
638
"c": single_char_format,
639
"0": function(val, flags){return num_flag("0", flags)},
640
"1": function(val, flags){return num_flag("1", flags)},
641
"2": function(val, flags){return num_flag("2", flags)},
642
"3": function(val, flags){return num_flag("3", flags)},
643
"4": function(val, flags){return num_flag("4", flags)},
644
"5": function(val, flags){return num_flag("5", flags)},
645
"6": function(val, flags){return num_flag("6", flags)},
646
"7": function(val, flags){return num_flag("7", flags)},
647
"8": function(val, flags){return num_flag("8", flags)},
648
"9": function(val, flags){return num_flag("9", flags)},
649
"-": neg_flag,
650
" ": space_flag,
651
"+": sign_flag,
652
".": decimal_point_flag,
653
"#": alternate_flag
654
}
655
656
// exception thrown when an unsupported char is encountered in legacy format
703
if(self === undefined){
704
throw _b_.TypeError.$factory(
705
"not enough arguments for format string")
732
throw _b_.ValueError.$factory(
733
"unsupported format character '" + invalid_char +
734
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
735
") at index " + newpos)
736
}else if(err.name === "NotANumber"){
737
var try_char = s[newpos],
738
cls = self.__class__
739
if(!cls){
740
if(typeof(self) === "string"){
741
cls = "str"
742
}else{
748
throw _b_.TypeError.$factory("%" + try_char +
749
" format: a number is required, not " + cls)
750
}else{
782
}while(pos < length)
783
784
if(argpos !== null){
785
if(args.length > argpos){
786
throw _b_.TypeError.$factory(
787
"not enough arguments for format string")
788
}else if(args.length < argpos){
789
throw _b_.TypeError.$factory(
790
"not all arguments converted during string formatting")
792
}else if(nbph == 0){
793
throw _b_.TypeError.$factory(
794
"not all arguments converted during string formatting")
802
var $ = $B.args("__mul__", 2, {self: null, other: null},
803
["self", "other"], arguments, {}, null, null)
804
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
805
"Can't multiply sequence by non-int of type '" +
806
$B.get_class($.other).__name__ + "'")}
807
var $res = ""
808
for(var i = 0; i< $.other; i++){$res += $.self.valueOf()}
817
res = res.replace(/\\/g, "\\\\")
818
if(res.search('"') == -1 && res.search("'") == -1){
819
return "'" + res + "'"
820
}else if(self.search('"') == -1){
821
return '"' + res + '"'
822
}
823
var qesc = new RegExp("'", "g") // to escape single quote
824
res = "'" + res.replace(qesc, "\\'") + "'"
828
str.__setitem__ = function(self, attr, value){
829
throw _b_.TypeError.$factory(
830
"'str' object does not support item assignment")
840
if(typeof other !== "string"){throw _b_.TypeError.$factory(
841
"unorderable types: 'str' > " + $B.get_class(other).__name__ + "()")}
844
$comp_func += "" // source code
845
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
854
var $notimplemented = function(self, other){
855
throw NotImplementedError.$factory(
856
"OPERATOR not implemented for class str")
859
// Copy static methods from unicode
860
var from_unicode = [
861
"title",
862
"capitalize",
863
"casefold",
864
"islower",
865
"isupper",
866
"istitle",
867
"isspace",
868
"isalpha",
869
"isalnum",
870
"isdecimal",
871
"isdigit",
872
"isnumeric",
873
"isidentifier",
874
"isprintable",
875
"lower",
876
"swapcase",
877
"upper"
878
]
884
str.center = function(){
885
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
886
["self", "width", "fillchar"],
887
arguments, {fillchar:" "}, null, null),
888
self = $.self
900
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
901
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
903
if(!(typeof $.sub == "string")){throw _b_.TypeError.$factory(
904
"Can't convert '" + $B.get_class($.sub).__name__ +
905
"' object to str implicitly")}
909
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
910
else{_slice = _b_.slice.$factory($.start, $.self.length)}
915
if($.sub.length == 0){
916
if($.start == $.self.length){return 1}
917
else if(substr.length == 0){return 0}
918
return substr.length + 1
920
var n = 0,
921
pos = 0
922
while(pos < substr.length){
923
pos = substr.indexOf($.sub, pos)
924
if(pos >= 0){n++; pos += $.sub.length}
925
else{break}
931
if (encoding === undefined){encoding = "utf-8"}
932
if(encoding == "rot13" || encoding == "rot_13"){
937
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
938
res += String.fromCharCode(String.charCodeAt(char) + 13)
939
}else if(("m" < char && char <= "z") ||
940
("M" < char && char <= "Z")){
941
res += String.fromCharCode(String.charCodeAt(char) - 13)
950
// Return True if the string ends with the specified suffix, otherwise
951
// return False. suffix can also be a tuple of suffixes to look for.
952
// With optional start, test beginning at that position. With optional
956
["self", "suffix", "start", "end"],
957
arguments, {start: 0, end: null}, null, null)
964
var s = $.self.substring($.start, $.end)
965
for(var i = 0, len = suffixes.length; i < len; i++){
969
if(suffix.length <= s.length &&
970
s.substr(s.length - suffix.length) == suffix){return true}
976
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
977
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
978
var s = $B.$GetInt($.tabsize),
979
col = 0,
980
pos = 0,
981
res = ""
982
if(s == 1){return self.replace(/\t/g," ")}
983
while(pos < self.length){
991
res += car
992
col = 0
993
break
994
default:
995
res += car
996
col++
997
break
998
}
999
pos++
1000
}
1006
// Return the lowest index in the string where substring sub is found,
1007
// such that sub is contained in the slice s[start:end]. Optional
1008
// arguments start and end are interpreted as in slice notation.
1011
{self: null, sub: null, start: null, end: null},
1012
["self", "sub", "start", "end"],
1013
arguments, {start: 0, end: null}, null, null)
1017
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1018
throw _b_.TypeError.$factory("slice indices must be " +
1019
"integers or None or have an __index__ method")}
1020
var s = $.self.substring($.start, $.end)
1022
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1023
if(s.length + $.sub.length == 0){return -1}
1025
var last_search = s.length - $.sub.length
1026
for(var i = 0; i <= last_search; i++){
1027
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1038
// a.x[z]!r:...
1039
// the object has attributes :
1040
// - name : "a"
1041
// - name_ext : [".x", "[z]"]
1042
// - conv : r
1043
// - spec : rest of string after :
1051
// No : in the string : it only contains a name
1052
name = fmt_string
1053
}else{
1054
// name is before the first ":"
1055
// spec (the format specification) is after
1056
name = elts[0]
1060
var elts = name.split("!")
1061
if(elts.length > 1){
1062
name = elts[0]
1063
conv = elts[1] // conversion flag
1064
if(conv.length !== 1 || "ras".search(conv) == -1){
1065
throw _b_.ValueError.$factory("wrong conversion flag " + conv)
1070
// "name' may be a subscription or attribute
1071
// Put these "extensions" in the list "name_ext"
1072
function name_repl(match){
1073
name_ext.push(match)
1075
}
1076
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1077
name = name.replace(name_ext_re, name_repl)
1078
}
1085
var $ = $B.args("format", 1, {self: null}, ["self"],
1086
arguments, {}, "$args", "$kw")
1087
1088
// Parse self to detect formatting instructions
1089
// Create a list "parts" made of sections of the string :
1090
// - elements of even rank are literal text
1091
// - elements of odd rank are "format objects", built from the
1092
// format strings in self (of the form {...})
1103
text += "{"
1104
pos += 2
1105
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1112
// Store current literal text
1113
parts.push(text)
1114
1115
// Search the end of the format string, ie the } closing the
1116
// opening {. Since the string can contain other pairs {} for
1117
// nested formatting, an integer nb is incremented for each { and
1118
// decremented for each } ; the end of the format string is
1119
// reached when nb == 0
1120
var end = pos + 1,
1121
nb = 1
1122
while(end < _len){
1123
if(self.charAt(end) == "{"){nb++; end++}
1124
else if(self.charAt(end) == "}"){
1125
nb--; end++
1126
if(nb == 0){
1129
1130
// Create a format object, by function parse_format
1131
var fmt_obj = parse_format(fmt_string)
1132
1133
// If no name is explicitely provided, use the rank
1134
if(!fmt_obj.name){
1141
// In this case, evaluate them using the positional
1142
// or keyword arguments passed to format()
1144
if(/\d+/.exec(key)){
1145
// If key is numeric, search in positional
1146
// arguments
1169
if(text){parts.push(text)}
1170
// Apply formatting to the values passed to format()
1177
// Format objects
1178
fmt = parts[i]
1179
if(fmt.name.charAt(0).search(/\d/)>-1){
1180
// Numerical reference : use positional arguments
1181
var pos = parseInt(fmt.name),
1191
// Attribute
1192
value = _b_.getattr(value, ext.substr(1))
1193
}else{
1194
// Subscription
1197
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1198
value = _b_.getattr(value, "__getitem__")(key)
1202
// If the conversion flag is set, first call a function to convert
1203
// the value
1204
if(fmt.conv == "a"){value = _b_.ascii(value)}
1205
else if(fmt.conv == "r"){value = _b_.repr(value)}
1206
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1220
throw NotImplementedError.$factory(
1221
"function format_map not implemented yet")
1242
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1243
"sequence item " + count + ": expected str instance, " +
1244
$B.get_class(obj2).__name__ + " found")}
1247
if(_b_.isinstance(err, _b_.StopIteration)){
1248
$B.current_exception = ce
1249
break
1250
}
1258
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1259
["self", "width", "fillchar"],
1260
arguments, {fillchar: " "}, null, null)
1267
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1268
arguments, {chars:_b_.None}, null, null)
1269
if($.chars === _b_.None){return $.self.trimLeft()}
1270
for(var i = 0; i < $.self.length; i++){
1271
if($.chars.indexOf($.self.charAt(i)) === -1){
1272
return $.self.substring(i)
1280
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1281
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1288
// If there is only one argument, it must be a dictionary mapping
1289
// Unicode ordinals (integers) or characters (strings of length 1) to
1290
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1292
if(! _b_.isinstance($.x, _b_.dict)){
1293
throw _b_.TypeError.$factory(
1294
"maketrans only argument must be a dict")
1297
for(var i = 0, len = items.length; i < len; i++){
1298
var k = items[i][0],
1299
v = items[i][1]
1300
if(! _b_.isinstance(k, _b_.int)){
1301
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1302
k = _b_.ord(k)
1303
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1306
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1307
throw _b_.TypeError.$factory("dictionary value " + v +
1315
// and in the resulting dictionary, each character in x will be mapped
1316
// to the character at the same position in y
1319
}else if($.x.length !== $.y.length){
1320
throw _b_.TypeError.$factory(
1321
"maketrans arguments must be strings or same length")
1327
if(! _b_.isinstance($.z, _b_.str)){
1328
throw _b_.TypeError.$factory(
1329
"maketrans third argument must be a string")
1335
for(var i = 0, len = $.x.length; i < len; i++){
1336
_t.$numeric_dict[_b_.ord($.x.charAt(i))] =
1337
_b_.ord($.y.charAt(i))
1338
}
1339
for(var k in toNone){
1340
_t.$numeric_dict[k] = _b_.None
1341
}
1342
return _t
1343
}
1344
}
1348
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1349
arguments, {}, null, null)
1351
check_str($.sep)
1352
var i = $.self.indexOf($.sep)
1353
if (i == -1){return _b_.tuple.$factory([$.self, "", ""])}
1354
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1355
$.self.substring(i + $.sep.length)])
1356
}
1357
1358
function $re_escape(str){
1359
var specials = "[.*+?|()$^"
1360
for(var i = 0, len = specials.length; i < len; i++){
1361
var re = new RegExp("\\"+specials.charAt(i), "g")
1362
str = str.replace(re, "\\"+specials.charAt(i))
1363
}
1364
return str
1371
var $ = $B.args("replace", 4,
1372
{self: null, old: null, $$new: null, count: null},
1373
["self", "old", "$$new", "count"],
1374
arguments, {count: -1}, null, null),
1375
count = $.count,
1376
self = $.self,
1377
old = $.old,
1378
_new = $.$$new
1385
"' object cannot be interpreted as an integer")
1386
}else if(isinstance(count, _b_.float)){
1387
throw _b_.TypeError.$factory("integer argument expected, got float")
1388
}
1389
if(count == 0){return self}
1390
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1391
if(old == ""){
1392
if(_new == ""){return self}
1393
if(self == ""){return _new}
1394
var elts = self.split("")
1395
if(count > -1 && elts.length >= count){
1396
var rest = elts.slice(count).join("")
1397
return _new + elts.slice(0, count).join(_new) + rest
1398
}else{return _new + elts.join(_new) + _new}
1413
if(count < 0){count = res.length}
1414
while(count > 0){
1415
pos = res.indexOf(old, pos)
1416
if(pos < 0){break}
1417
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1418
pos = pos + _new.length
1419
count--
1425
// Return the highest index in the string where substring sub is found,
1426
// such that sub is contained within s[start:end]. Optional arguments
1429
{self: null, sub: null, start: null, end: null},
1430
["self", "sub", "start", "end"],
1431
arguments, {start: 0, end: null}, null, null)
1443
for(var i = $.end - sublen; i >= $.start; i--){
1444
if($.self.substr(i, sublen) == $.sub){return i}
1451
var res = str.rfind.apply(null, arguments)
1452
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1457
var $ = $B.args("rjust",3,
1458
{self: null, width: null, fillchar: null},
1459
["self", "width", "fillchar"],
1460
arguments, {fillchar: " "}, null, null)
1468
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1469
arguments, {}, null, null)
1473
var items = str.partition(self, sep).reverse()
1474
for(var i = 0; i < items.length; i++){
1475
items[i] = items[i].split("").reverse().join("")
1481
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1482
["self", "sep", "maxsplit"], arguments,
1483
{sep: _b_.None, maxsplit: -1}, null, null),
1484
sep = $.sep
1487
var rev_str = reverse($.self),
1488
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1499
str.rstrip = function(self, x){
1500
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1501
arguments, {chars: _b_.None}, null, null)
1502
if($.chars === _b_.None){return $.self.trimRight()}
1503
for(var j = $.self.length-1; j >= 0; j--){
1504
if($.chars.indexOf($.self.charAt(j)) == -1){
1505
return $.self.substring(0, j + 1)
1512
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1513
["self", "sep", "maxsplit"], arguments,
1514
{sep: _b_.None, maxsplit: -1}, null, null),
1515
sep = $.sep,
1516
maxsplit = $.maxsplit,
1517
self = $.self,
1518
pos = 0
1519
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1520
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1521
if(sep === _b_.None){
1523
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1524
if(pos === self.length - 1){return [self]}
1525
var name = ""
1527
if(self.charAt(pos).search(/\s/) == -1){
1528
if(name == ""){name = self.charAt(pos)}
1529
else{name += self.charAt(pos)}
1549
var res = [],
1550
s = "",
1551
seplen = sep.length
1552
if(maxsplit == 0){return [self]}
1553
while(pos < self.length){
1554
if(self.substr(pos, seplen) == sep){
1574
["self", "keepends"], arguments, {keepends: false}, null, null)
1575
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1576
throw _b_.TypeError.$factory("integer argument expected, got " +
1583
start = pos,
1584
pos = 0,
1585
self = $.self
1586
while(pos < self.length){
1587
if(self.substr(pos, 2) == "\r\n"){
1588
res.push(self.substring(start, pos + 2))
1589
start = pos + 2
1591
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1592
res.push(self.substring(start, pos + 1))
1593
start = pos + 1
1594
pos = start
1595
}else{pos++}
1596
}
1597
var rest = self.substr(start)
1598
if(rest){res.push(rest)}
1599
return res
1600
}else{
1607
// Return True if string starts with the prefix, otherwise return False.
1608
// prefix can also be a tuple of prefixes to look for. With optional
1609
// start, test string beginning at that position. With optional end,
1611
var $ = $B.args("startswith", 4,
1612
{self: null, prefix: null, start: null, end: null},
1613
["self", "prefix", "start", "end"],
1614
arguments, {start: 0, end: null}, null, null)
1621
var s = $.self.substring($.start, $.end)
1622
for(var i = 0, len = prefixes.length; i < len; i++){
1633
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1634
arguments, {chars: _b_.None}, null, null)
1635
if($.chars === _b_.None){return $.self.trim()}
1636
for(var i = 0; i < $.self.length; i++){
1637
if($.chars.indexOf($.self.charAt(i)) == -1){
1638
break
1641
for(var j = $.self.length - 1; j >= i; j--){
1642
if($.chars.indexOf($.self.charAt(j)) == -1){
1643
break
1649
str.translate = function(self,table){
1650
var res = [],
1651
pos = 0
1652
if(isinstance(table, _b_.dict)){
1653
for(var i = 0, len = self.length; i < len; i++){
1654
var repl = _b_.dict.get(table,self.charCodeAt(i), -1)
1655
if(repl == -1){res[pos++] = self.charAt(i)}
1656
else if(repl !== None){res[pos++] = _b_.chr(repl)}
1664
["self", "width"], arguments, {}, null, null)
1665
if($.width <= self.length){return self}
1667
case "+":
1668
case "-":
1669
return self.charAt(0) +
1670
"0".repeat($.width - self.length) + self.substr(1)
1680
case "string":
1681
return arg
1682
case "number":
1683
if(isFinite(arg)){return arg.toString()}
1689
// class or its subclasses, but the attribute __str__ of the
1690
// class metaclass (usually "type") or its subclasses (usually
1691
// "object")
1692
// The metaclass is the attribute __class__ of the class dictionary
1706
if($B.debug > 1){console.log(err)}
1707
console.log("Warning - no method __str__ or __repr__, " +
1708
"default to toString", arg)
1716
if(cls === undefined){
1717
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1738
var args = [],
1739
pos = 0
1740
if(arguments.length > 0){
1741
var args = [arguments[0].valueOf()],
1742
pos = 1
1743
for(var i = 1, len = arguments.length; i < len; i++){
1744
args[pos++] = arguments[i]
1760
// Function to parse the 2nd argument of format()
1761
$B.parse_format_spec = function(spec){
1765
var pos = 0,
1766
aligns = "<>=^",
1767
digits = "0123456789",
1768
types = "bcdeEfFgGnosxX%",
1770
if(align_pos != -1){
1771
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1772
// If the second char is also an alignment specifier, the
1773
// first char is the fill value
1774
this.fill = spec.charAt(0)
1775
this.align = spec.charAt(1)
1776
pos = 2
1777
}else{
1778
// The first character defines alignment : fill defaults to ' '
1793
if(car == "+" || car == "-" || car == " "){
1794
this.sign = car
1795
pos++
1796
car = spec.charAt(pos)
1798
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1799
if(car == "0"){
1806
while(car && digits.indexOf(car) > -1){
1807
if(this.width === undefined){this.width = car}
1808
else{this.width += car}
1809
pos++
1810
car = spec.charAt(pos)
1812
if(this.width !== undefined){this.width = parseInt(this.width)}
1813
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1814
if(car == "."){
1815
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1816
throw _b_.ValueError.$factory(
1817
"Missing precision in format spec")
1819
this.precision = spec.charAt(pos + 1)
1820
pos += 2
1821
car = spec.charAt(pos)
1822
while(car && digits.indexOf(car) > -1){
1823
this.precision+=car
1824
pos++
1825
car = spec.charAt(pos)
1829
if(car && types.indexOf(car) > -1){
1830
this.type = car
1831
pos++
1832
car = spec.charAt(pos)
1833
}
1834
if(pos !== spec.length){
1839
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1840
(this.align || "") +
1841
(this.sign || "") +
1842
(this.alternate ? "#" : "") +
1843
(this.sign_aware ? "0" : "") +
1844
(this.width || "") +
1845
(this.comma ? "," : "") +
1846
(this.precision ? "." + this.precision : "") +
1847
(this.type || "")
1852
if(fmt.width && s.length < fmt.width){
1853
var fill = fmt.fill || " ",
1854
align = fmt.align || "<",
1855
missing = fmt.width - s.length
1857
case "<":
1858
return s + fill.repeat(missing)
1859
case ">":
1860
return fill.repeat(missing) + s
1861
case "=":
1862
if("+-".indexOf(s.charAt(0)) > -1){
1863
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1867
case "^":
1868
var left = parseInt(missing / 2)
1869
return fill.repeat(left) + s + fill.repeat(missing - left)
1882
$B.parse_fstring = function(string){
1883
// Parse a f-string
1884
var elts = [],
1885
pos = 0,
1894
if(car == "{"){
1895
if(string.charAt(pos+1) == "{"){
1896
ctype = "string"
1897
current = "{"
1909
}else{
1910
throw Error(" f-string: single '}' is not allowed")
1911
}
1912
}else{
1922
if(car == "{"){
1923
if(string.charAt(i+1) == "{"){
1924
current += "{"
1925
i += 2
1934
current += car
1935
i += 2
1936
}else{
1937
throw Error(" f-string: single '}' is not allowed")
1938
}
1939
}else{
1940
current += car
1941
i++
1942
}
1943
}
1945
}else{
1946
// End of expression is the } matching the opening {
1947
// There may be nested braces
1948
var i = pos,
1949
nb_braces = 1,
1971
// backslash is not allowed in expressions
1972
throw Error("f-string expression part cannot include a" +
1973
" backslash")
1974
}else if(nb_paren == 0 && car == "!" && current.fmt === null &&
1975
":}".indexOf(string.charAt(i + 2))>-1){
1976
if(current.expression.length == 0){
1980
throw Error("f-string: invalid conversion character:" +
1981
" expected 's', 'r', or 'a'")
1982
}else{
1996
if(string.substr(i, 3) == '"""'){
1997
var end = string.indexOf('"""', i + 3)
1998
if(end == -1){
1999
throw Error("f-string: unterminated string")
2000
}else{
2001
var trs = string.substring(i, end + 3)
2002
trs = trs.replace("\n", "\\n\\")
2007
var end = string.indexOf('"', i + 1)
2008
if(end == -1){
2009
throw Error("f-string: unterminated string")
2010
}else{
2011
current.expression += string.substring(i, end + 1)
2012
i = end + 1
2021
i++
2022
}
2023
}
2024
if(nb_braces>0){
2025
throw Error("f-string: expected '}'")
2026
}
2027
}
2028
}