Permalink
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 25, 2020
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 20, 2018
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
Dec 18, 2019
Dec 18, 2019
Mar 19, 2018
Jan 14, 2015
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
Jul 8, 2020
Mar 19, 2018
Mar 19, 2018
Mar 27, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 2, 2019
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Apr 16, 2019
Mar 19, 2018
Apr 16, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Nov 12, 2018
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 2, 2019
Mar 19, 2018
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
Mar 19, 2018
Jun 11, 2020
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
May 24, 2019
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
Feb 27, 2020
Feb 27, 2020
Feb 27, 2020
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 14, 2018
Jan 26, 2020
Mar 19, 2018
Mar 19, 2018
Nov 15, 2019
Jul 28, 2018
Oct 27, 2019
Nov 2, 2018
Oct 27, 2019
Nov 2, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 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
Jun 29, 2017
Jun 29, 2017
Oct 13, 2019
Jun 29, 2017
Jul 10, 2017
Jul 10, 2017
Mar 19, 2018
Mar 19, 2018
Jun 20, 2020
Oct 13, 2019
Apr 25, 2020
Newer
100644
2585 lines (2369 sloc)
81.9 KB
21
if($.start === null || $.start === _b_.None){$.start = 0}
22
else if($.start < 0){
23
$.start += $.self.length
24
$.start = Math.max(0, $.start)
25
}
26
if($.end === null || $.end === _b_.None){$.end = $.self.length}
27
else if($.end < 0){
28
$.end += $.self.length
29
$.end = Math.max(0, $.end)
30
}
32
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
33
throw _b_.TypeError.$factory("slice indices must be integers " +
34
"or None or have an __index__ method")
35
}
52
if(!(typeof other === "string")){
53
try{return getattr(other, "__radd__")(self)}
54
catch(err){
55
throw _b_.TypeError.$factory("Can't convert " +
63
throw _b_.TypeError.$factory("'in <string>' requires " +
64
"string as left operand, not " + item.__class__)
65
}
66
if(typeof item == "string"){
67
var nbcar = item.length
68
}else{
69
var nbcar = _b_.len(item)
70
}
71
if(nbcar == 0) {return true} // a string contains the empty string
72
if(self.length == 0){return nbcar == 0}
73
for(var i = 0, len = self.length; i < len; i++){
74
if(self.substr(i, nbcar) == item){return true}
83
// __dir__must be assigned explicitely because attribute resolution for
84
// builtin classes doesn't use __mro__
88
if(other === undefined){ // compare object "self" to class "str"
89
return self === str
99
if(fmt.type && fmt.type != "s"){
100
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
108
if(fmt.sign !== undefined){
109
throw _b_.ValueError.$factory(
110
"Sign not allowed in string format specifier")
123
if(arg < 0) {pos += self.length}
124
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
125
throw _b_.IndexError.$factory("string index out of range")
126
}
127
if(isinstance(arg, slice)) {
128
var s = _b_.slice.$conv_for_seq(arg, self.length),
129
start = s.start,
130
stop = s.stop,
131
step = s.step
132
var res = "",
134
if(step > 0){
135
if(stop <= start){return ""}
136
for(var i = start; i < stop; i += step){res += self.charAt(i)}
138
if(stop >= start){return ''}
139
for(var i = start; i > stop; i += step){res += self.charAt(i)}
159
var x = prefix
160
x = (x ^ (p.charCodeAt(0) << 7)) & mask
161
for(var i = 0, len = p.length; i < len; i++){
162
x = ((1000003 * x) ^ p.charCodeAt(i)) & mask
163
}
164
x = (x ^ p.length) & mask
165
x = (x ^ suffix) & mask
234
// left adjusted
235
return s + get_char_array(padding - s.length, flags.pad_char)
236
}
237
}
238
246
if(val.__class__ === $B.long_int){
247
s = $B.long_int.to_base(val, 10)
248
}else{
249
s = val.toString()
251
if(s[0] === "-"){
252
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
263
if(val === Infinity){
264
val = "inf"
265
}else if(val === -Infinity){
266
val = "-inf"
267
}else{
268
val = "nan"
290
var str_format = function(val, flags) {
291
// string format supports left and right padding
292
flags.pad_char = " " // even if 0 padding is defined, don't use it
298
if(val.__class__ === $B.long_int){
299
val = $B.long_int.to_base(val, 10)
300
}else{
301
val = parseInt(val)
319
var repr_format = function(val, flags) {
320
flags.pad_char = " " // even if 0 padding is defined, don't use it
321
return format_padding(repr(val), flags)
322
}
324
var ascii_format = function(val, flags) {
325
flags.pad_char = " " // even if 0 padding is defined, don't use it
326
return format_padding(ascii(val), flags)
327
}
339
flags.precision = parseInt(flags.precision, 10)
340
validate_precision(flags.precision)
341
}
342
return parseFloat(val)
343
}
346
var trailing_zeros = /(.*?)(0+)([eE].*)/,
347
leading_zeros = /\.(0*)/,
348
trailing_dot = /\.$/
350
var validate_precision = function(precision) {
351
// force precision to limits of javascript
356
var floating_point_format = function(val, upper, flags){
357
val = _float_helper(val, flags),
358
v = val.toString(),
359
v_len = v.length,
360
dot_idx = v.indexOf('.')
361
if(dot_idx < 0){dot_idx = v_len}
362
if(val < 1 && val > -1){
363
var zeros = leading_zeros.exec(v),
364
numzeros
365
if(zeros){
370
if(numzeros >= 4){
371
val = format_sign(val, flags) + format_float_precision(val, upper,
372
flags, _floating_g_exp_helper)
373
if(!flags.alternate){
386
return format_padding(format_sign(val, flags) +
387
format_float_precision(val, upper, flags,
388
function(val, precision) {
389
return val.toFixed(min(precision, v_len - dot_idx) +
390
numzeros)
391
}),
392
flags
393
)
394
}
395
396
if(dot_idx > flags.precision){
397
val = format_sign(val, flags) + format_float_precision(val, upper,
398
flags, _floating_g_exp_helper)
399
if(! flags.alternate){
411
return format_padding(format_sign(val, flags) +
412
format_float_precision(val, upper, flags,
413
function(val, precision) {
414
if(!flags.decimal_point){
415
precision = min(v_len - 1, 6)
416
}else if (precision > v_len){
417
if(! flags.alternate){
418
precision = v_len
419
}
421
if(precision < dot_idx){
422
precision = dot_idx
423
}
424
return val.toFixed(precision - dot_idx)
425
}),
426
flags
427
)
430
var _floating_g_exp_helper = function(val, precision, flags, upper){
431
if(precision){--precision}
434
var e_idx = val.lastIndexOf("e")
435
if(e_idx > val.length - 4){
436
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
439
return val
440
}
441
442
// fF
443
var floating_point_decimal_format = function(val, upper, flags) {
444
val = _float_helper(val, flags)
445
return format_padding(format_sign(val, flags) +
446
format_float_precision(val, upper, flags,
447
function(val, precision, flags) {
448
val = val.toFixed(precision)
449
if(precision === 0 && flags.alternate){
450
val += '.'
451
}
452
return val
453
}),
454
flags
455
)
456
}
457
458
var _floating_exp_helper = function(val, precision, flags, upper) {
459
val = val.toExponential(precision)
460
// pad exponent to two digits
473
return format_padding(format_sign(val, flags) +
474
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
500
if(flags.alternate){
501
if(ret.charAt(0) === "-"){
502
if(upper){ret = "-0X" + ret.slice(1)}
503
else{ret = "-0x" + ret.slice(1)}
504
}else{
505
if(upper){ret = "0X" + ret}
506
else{ret = "0x" + ret}
516
if(val.__class__ === $B.long_int){
517
ret = $B.long_int.to_base(8)
518
}else{
519
ret = parseInt(val)
520
ret = ret.toString(8)
536
if(flags.alternate){
537
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
538
else{ret = "0o" + ret}
543
function series_of_bytes(val, flags){
544
if(val.__class__ && val.__class__.$buffer_protocol){
545
var it = _b_.iter(val),
546
ints = []
547
while(true){
548
try{
549
ints.push(_b_.next(it))
550
}catch(err){
551
if(err.__class__ === _b_.StopIteration){
552
var b = _b_.bytes.$factory(ints)
553
return format_padding(_b_.bytes.decode(b, "ascii"), flags)
554
}
555
throw err
556
}
557
}
558
}else{
559
try{
560
bytes_obj = $B.$getattr(val, "__bytes__")
561
return format_padding(_b_.bytes.decode(bytes_obj), flags)
562
}catch(err){
563
if(err.__class__ === _b_.AttributeError){
564
throw _b_.TypeError.$factory("%b does not accept '" +
565
$B.class_name(val) + "'")
566
}
567
throw err
568
}
569
}
570
}
571
573
if(isinstance(val, str) && val.length == 1){
574
return val
575
}else if(isinstance(val, bytes) && val.source.length == 1){
576
val = val.source[0]
577
}else{
578
try{
579
val = _b_.int.$factory(val) // yes, floats are valid (they are cast to int)
580
}catch (err){
581
throw _b_.TypeError.$factory("%c requires int or char")
582
}
587
var num_flag = function(c, flags){
588
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
589
flags.pad_char = "0"
595
flags.precision = (flags.precision || "") + c
596
}
597
}
598
599
var decimal_point_flag = function(val, flags) {
601
// can only have one decimal point
602
throw new UnsupportedChar()
603
}
604
flags.decimal_point = true
605
}
606
607
var neg_flag = function(val, flags){
608
flags.pad_char = " " // overrides '0' flag
626
"s": str_format,
627
"d": num_format,
628
"i": num_format,
629
"u": num_format,
630
"o": octal_format,
631
"r": repr_format,
632
"a": ascii_format,
633
"g": function(val, flags){
634
return floating_point_format(val, false, flags)
635
},
636
"G": function(val, flags){return floating_point_format(val, true, flags)},
637
"f": function(val, flags){
638
return floating_point_decimal_format(val, false, flags)
639
},
640
"F": function(val, flags){
641
return floating_point_decimal_format(val, true, flags)
642
},
643
"e": function(val, flags){
644
return floating_point_exponential_format(val, false, flags)
645
},
646
"E": function(val, flags){
647
return floating_point_exponential_format(val, true, flags)
648
},
649
"x": function(val, flags){return signed_hex_format(val, false, flags)},
650
"X": function(val, flags){return signed_hex_format(val, true, flags)},
651
"c": single_char_format,
652
"0": function(val, flags){return num_flag("0", flags)},
653
"1": function(val, flags){return num_flag("1", flags)},
654
"2": function(val, flags){return num_flag("2", flags)},
655
"3": function(val, flags){return num_flag("3", flags)},
656
"4": function(val, flags){return num_flag("4", flags)},
657
"5": function(val, flags){return num_flag("5", flags)},
658
"6": function(val, flags){return num_flag("6", flags)},
659
"7": function(val, flags){return num_flag("7", flags)},
660
"8": function(val, flags){return num_flag("8", flags)},
661
"9": function(val, flags){return num_flag("9", flags)},
662
"-": neg_flag,
663
" ": space_flag,
664
"+": sign_flag,
665
".": decimal_point_flag,
666
"#": alternate_flag
667
}
668
669
// exception thrown when an unsupported char is encountered in legacy format
716
if(self === undefined){
717
throw _b_.TypeError.$factory(
718
"not enough arguments for format string")
745
throw _b_.ValueError.$factory(
746
"unsupported format character '" + invalid_char +
747
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
748
") at index " + newpos)
749
}else if(err.name === "NotANumber"){
750
var try_char = s[newpos],
751
cls = self.__class__
752
if(!cls){
753
if(typeof(self) === "string"){
754
cls = "str"
755
}else{
761
throw _b_.TypeError.$factory("%" + try_char +
762
" format: a number is required, not " + cls)
763
}else{
795
}while(pos < length)
796
797
if(argpos !== null){
798
if(args.length > argpos){
799
throw _b_.TypeError.$factory(
800
"not enough arguments for format string")
801
}else if(args.length < argpos){
802
throw _b_.TypeError.$factory(
803
"not all arguments converted during string formatting")
805
}else if(nbph == 0){
806
throw _b_.TypeError.$factory(
807
"not all arguments converted during string formatting")
815
var $ = $B.args("__mul__", 2, {self: null, other: null},
816
["self", "other"], arguments, {}, null, null)
817
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
818
"Can't multiply sequence by non-int of type '" +
830
res = self.replace(/\\/g, "\\\\")
831
// special cases
832
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
833
replace(new RegExp("\b", "g"), "\\x08").
835
replace(new RegExp("\f", "g"), "\\x0c").
836
replace(new RegExp("\n", "g"), "\\n").
837
replace(new RegExp("\r", "g"), "\\r").
838
replace(new RegExp("\t", "g"), "\\t")
840
// Replace unassigned code point by \uabcd...
841
// Uses function $B.is_unicode_cn() in unicode_data.js
842
var repl = ''
843
for(var i = 0; i < res.length; i++){
844
if($B.is_unicode_cn(res.codePointAt(i))){
845
var s = res.codePointAt(i).toString(16)
846
while(s.length < 4){
847
s = '0' + s
848
}
849
repl += '\\u' + s
850
}else{
851
repl += res.charAt(i)
852
}
853
}
854
res = repl
855
if(res.search('"') == -1 && res.search("'") == -1){
856
return "'" + res + "'"
857
}else if(self.search('"') == -1){
858
return '"' + res + '"'
859
}
860
var qesc = new RegExp("'", "g") // to escape single quote
861
res = "'" + res.replace(qesc, "\\'") + "'"
865
str.__setitem__ = function(self, attr, value){
866
throw _b_.TypeError.$factory(
867
"'str' object does not support item assignment")
869
var combining = []
870
for(var cp = 0x300; cp <= 0x36F; cp++){
871
combining.push(String.fromCharCode(cp))
872
}
873
var combining_re = new RegExp("(" + combining.join("|") + ")")
885
$comp_func += "" // source code
886
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
895
var $notimplemented = function(self, other){
896
throw NotImplementedError.$factory(
897
"OPERATOR not implemented for class str")
900
str.capitalize = function(self){
901
var $ = $B.args("capitalize", 1, {self}, ["self"],
902
arguments, {}, null, null)
903
if(self.length == 0){return ""}
904
return self.charAt(0).toUpperCase() + self.substr(1)
905
}
906
907
str.casefold = function(self){
908
var $ = $B.args("casefold", 1, {self}, ["self"],
909
arguments, {}, null, null),
910
res = "",
911
char,
912
cf
913
for(var i = 0, len = self.length; i < len; i++){
914
char = self.charCodeAt(i)
915
cf = $B.unicode_casefold[char]
916
if(cf){
917
cf.forEach(function(cp){
918
res += String.fromCharCode(cp)
919
})
920
}else{
921
res += self.charAt(i).toLowerCase()
922
}
923
}
924
return res
925
}
927
str.center = function(){
928
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
929
["self", "width", "fillchar"],
930
arguments, {fillchar:" "}, null, null),
931
self = $.self
943
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
944
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
952
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
953
else{_slice = _b_.slice.$factory($.start, $.self.length)}
958
if($.sub.length == 0){
959
if($.start == $.self.length){return 1}
960
else if(substr.length == 0){return 0}
961
return substr.length + 1
963
var n = 0,
964
pos = 0
965
while(pos < substr.length){
966
pos = substr.indexOf($.sub, pos)
967
if(pos >= 0){n++; pos += $.sub.length}
968
else{break}
973
str.encode = function(){
974
var $ = $B.args("encode", 3, {self: null, encoding: null, errors: null},
975
["self", "encoding", "errors"], arguments,
976
{encoding: "utf-8", errors: "strict"}, null, null)
977
if($.encoding == "rot13" || $.encoding == "rot_13"){
982
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
983
res += String.fromCharCode(String.charCodeAt(char) + 13)
984
}else if(("m" < char && char <= "z") ||
985
("M" < char && char <= "Z")){
986
res += String.fromCharCode(String.charCodeAt(char) - 13)
995
// Return True if the string ends with the specified suffix, otherwise
996
// return False. suffix can also be a tuple of suffixes to look for.
997
// With optional start, test beginning at that position. With optional
1001
["self", "suffix", "start", "end"],
1002
arguments, {start: 0, end: null}, null, null)
1009
var s = $.self.substring($.start, $.end)
1010
for(var i = 0, len = suffixes.length; i < len; i++){
1014
if(suffix.length <= s.length &&
1015
s.substr(s.length - suffix.length) == suffix){return true}
1021
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
1022
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
1023
var s = $B.$GetInt($.tabsize),
1024
col = 0,
1025
pos = 0,
1026
res = ""
1027
if(s == 1){return self.replace(/\t/g," ")}
1028
while(pos < self.length){
1036
res += car
1037
col = 0
1038
break
1039
default:
1040
res += car
1041
col++
1042
break
1043
}
1044
pos++
1045
}
1051
// Return the lowest index in the string where substring sub is found,
1052
// such that sub is contained in the slice s[start:end]. Optional
1053
// arguments start and end are interpreted as in slice notation.
1056
{self: null, sub: null, start: null, end: null},
1057
["self", "sub", "start", "end"],
1058
arguments, {start: 0, end: null}, null, null)
1062
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1063
throw _b_.TypeError.$factory("slice indices must be " +
1064
"integers or None or have an __index__ method")}
1065
// Can't use string.substring(start, end) because if end < start,
1066
// Javascript transforms it into substring(end, start)...
1067
var s = ""
1068
for(var i = $.start; i < $.end; i++){
1069
s += $.self.charAt(i)
1070
}
1072
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1073
if(s.length + $.sub.length == 0){return -1}
1075
var last_search = s.length - $.sub.length
1076
for(var i = 0; i <= last_search; i++){
1077
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1088
// a.x[z]!r:...
1089
// the object has attributes :
1090
// - name : "a"
1091
// - name_ext : [".x", "[z]"]
1092
// - conv : r
1093
// - spec : rest of string after :
1101
// No : in the string : it only contains a name
1102
name = fmt_string
1103
}else{
1104
// name is before the first ":"
1105
// spec (the format specification) is after
1106
name = elts[0]
1110
var elts = name.split("!")
1111
if(elts.length > 1){
1112
name = elts[0]
1113
conv = elts[1] // conversion flag
1117
// "name' may be a subscription or attribute
1118
// Put these "extensions" in the list "name_ext"
1119
function name_repl(match){
1120
name_ext.push(match)
1122
}
1123
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1124
name = name.replace(name_ext_re, name_repl)
1125
}
1132
// Parse self to detect formatting instructions
1133
// Create a list "parts" made of sections of the string :
1134
// - elements of even rank are literal text
1135
// - elements of odd rank are "format objects", built from the
1136
// format strings in self (of the form {...})
1147
text += "{"
1148
pos += 2
1149
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1156
// Store current literal text
1157
parts.push(text)
1158
1159
// Search the end of the format string, ie the } closing the
1160
// opening {. Since the string can contain other pairs {} for
1161
// nested formatting, an integer nb is incremented for each { and
1162
// decremented for each } ; the end of the format string is
1163
// reached when nb == 0
1164
var end = pos + 1,
1165
nb = 1
1166
while(end < _len){
1167
if(self.charAt(end) == "{"){nb++; end++}
1168
else if(self.charAt(end) == "}"){
1169
nb--; end++
1170
if(nb == 0){
1175
var fmt_obj = $B.parse_format(fmt_string)
1176
fmt_obj.raw_name = fmt_obj.name
1177
fmt_obj.raw_spec = fmt_obj.spec
1212
return parts
1213
}
1214
1215
str.format = function(self) {
1216
var $ = $B.args("format", 1, {self: null}, ["self"],
1217
arguments, {}, "$args", "$kw")
1218
1219
var parts = $B.split_format($.self)
1220
1231
1232
if(fmt.spec !== undefined){
1233
// "spec" may contain "nested replacement fields"
1234
// In this case, evaluate them using the positional
1235
// or keyword arguments passed to format()
1236
function replace_nested(name, key){
1237
if(/\d+/.exec(key)){
1238
// If key is numeric, search in positional
1239
// arguments
1240
return _b_.tuple.__getitem__($.$args,
1241
parseInt(key))
1242
}else{
1243
// Else try in keyword arguments
1244
return _b_.dict.__getitem__($.$kw, key)
1245
}
1246
}
1247
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1248
replace_nested)
1249
}
1251
// Numerical reference : use positional arguments
1252
var pos = parseInt(fmt.name),
1262
// Attribute
1263
value = _b_.getattr(value, ext.substr(1))
1264
}else{
1265
// Subscription
1268
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1269
value = _b_.getattr(value, "__getitem__")(key)
1273
// If the conversion flag is set, first call a function to convert
1274
// the value
1275
if(fmt.conv == "a"){value = _b_.ascii(value)}
1276
else if(fmt.conv == "r"){value = _b_.repr(value)}
1277
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1291
throw NotImplementedError.$factory(
1292
"function format_map not implemented yet")
1303
/* Return true if the string is empty or all characters in the string are
1304
ASCII, false otherwise. ASCII characters have code points in the range
1305
U+0000-U+007F. */
1306
for(var i = 0, len = self.length; i < len; i++){
1307
if(self.charCodeAt(i) > 127){return false}
1308
}
1309
return true
1310
}
1311
1312
str.isalnum = function(self){
1313
/* Return true if all characters in the string are alphanumeric and there
1314
is at least one character, false otherwise. A character c is alphanumeric
1315
if one of the following returns True: c.isalpha(), c.isdecimal(),
1316
c.isdigit(), or c.isnumeric(). */
1317
var $ = $B.args("isalnum", 1, {self: null}, ["self"],
1318
arguments, {}, null, null),
1319
char
1320
for(var i = 0, len = self.length; i < len; i++){
1321
char = self.charCodeAt(i)
1322
if(unicode_tables.Ll[char] ||
1323
unicode_tables.Lu[char] ||
1324
unicode_tables.Lm[char] ||
1325
unicode_tables.Lt[char] ||
1326
unicode_tables.Lo[char] ||
1327
unicode_tables.Nd[char] ||
1328
unicode_tables.digits[char] ||
1329
unicode_tables.numeric[char]){
1330
continue
1331
}
1332
return false
1333
}
1334
return true
1335
}
1336
1337
str.isalpha = function(self){
1338
/* Return true if all characters in the string are alphabetic and there is
1339
at least one character, false otherwise. Alphabetic characters are those
1340
characters defined in the Unicode character database as "Letter", i.e.,
1341
those with general category property being one of "Lm", "Lt", "Lu", "Ll",
1342
or "Lo". */
1343
var $ = $B.args("isalpha", 1, {self: null}, ["self"],
1344
arguments, {}, null, null),
1345
char
1346
for(var i = 0, len = self.length; i < len; i++){
1347
char = self.charCodeAt(i)
1348
if(unicode_tables.Ll[char] ||
1349
unicode_tables.Lu[char] ||
1350
unicode_tables.Lm[char] ||
1351
unicode_tables.Lt[char] ||
1352
unicode_tables.Lo[char]){
1353
continue
1354
}
1355
return false
1356
}
1357
return true
1358
}
1359
1360
str.isdecimal = function(self){
1361
/* Return true if all characters in the string are decimal characters and
1362
there is at least one character, false otherwise. Decimal characters are
1363
those that can be used to form numbers in base 10, e.g. U+0660,
1364
ARABIC-INDIC DIGIT ZERO. Formally a decimal character is a character in
1365
the Unicode General Category "Nd". */
1366
var $ = $B.args("isdecimal", 1, {self: null}, ["self"],
1367
arguments, {}, null, null),
1368
char
1369
for(var i = 0, len = self.length; i < len; i++){
1370
char = self.charCodeAt(i)
1371
if(! unicode_tables.Nd[char]){
1372
return false
1373
}
1374
}
1375
return self.length > 0
1376
}
1377
1378
str.isdigit = function(self){
1379
/* Return true if all characters in the string are digits and there is at
1380
least one character, false otherwise. */
1381
var $ = $B.args("isdigit", 1, {self: null}, ["self"],
1382
arguments, {}, null, null),
1383
char
1384
for(var i = 0, len = self.length; i < len; i++){
1385
char = self.charCodeAt(i)
1386
if(! unicode_tables.digits[char]){
1387
return false
1388
}
1389
}
1390
return self.length > 0
1391
}
1392
1393
str.isidentifier = function(self){
1394
/* Return true if the string is a valid identifier according to the
1395
language definition. */
1396
var $ = $B.args("isidentifier", 1, {self: null}, ["self"],
1397
arguments, {}, null, null),
1398
char
1399
if(self.length == 0){return false}
1400
else if(unicode_tables.XID_Start[self.charCodeAt(0)] === undefined){
1401
return false
1402
}else{
1403
for(var i = 1, len = self.length; i < len; i++){
1404
if(unicode_tables.XID_Continue[self.charCodeAt(i)] === undefined){
1405
return false
1406
}
1407
}
1408
}
1409
return true
1410
}
1411
1412
str.islower = function(self){
1413
/* Return true if all cased characters 4 in the string are lowercase and
1414
there is at least one cased character, false otherwise. */
1415
var $ = $B.args("islower", 1, {self: null}, ["self"],
1416
arguments, {}, null, null),
1417
has_cased = false,
1418
char
1419
1420
for(var i = 0, len = self.length; i < len; i++){
1421
char = self.charCodeAt(i)
1422
if(unicode_tables.Ll[char]){has_cased = true; continue}
1423
else if(unicode_tables.Lu[char] || unicode_tables.Lt[char]){
1424
return false
1425
}
1426
}
1427
return has_cased
1428
}
1429
1430
str.isnumeric = function(self){
1431
/* Return true if all characters in the string are numeric characters, and
1432
there is at least one character, false otherwise. Numeric characters
1433
include digit characters, and all characters that have the Unicode numeric
1434
value property, e.g. U+2155, VULGAR FRACTION ONE FIFTH. Formally, numeric
1435
characters are those with the property value Numeric_Type=Digit,
1436
Numeric_Type=Decimal or Numeric_Type=Numeric.*/
1437
var $ = $B.args("isnumeric", 1, {self: null}, ["self"],
1438
arguments, {}, null, null)
1439
for(var i = 0, len = self.length; i < len; i++){
1440
if(! unicode_tables.numeric[self.charCodeAt(i)]){
1441
return false
1442
}
1443
}
1444
return self.length > 0
1445
}
1446
1447
var printable,
1448
printable_gc = ['Cc', 'Cf', 'Co', 'Cs','Zl', 'Zp', 'Zs']
1449
1450
str.isprintable = function(self){
1451
/* Return true if all characters in the string are printable or the string
1452
is empty, false otherwise. Nonprintable characters are those characters
1453
defined in the Unicode character database as "Other" or "Separator",
1454
excepting the ASCII space (0x20) which is considered printable. */
1455
1456
// Set printable if not set yet
1457
if(printable === undefined){
1458
for(var i = 0; i < printable_gc.length; i++){
1459
var table = unicode_tables[printable_gc[i]]
1460
for(var cp in table){
1461
printable[cp] = true
1462
}
1463
}
1464
printable[32] = true
1465
}
1466
1467
var $ = $B.args("isprintable", 1, {self: null}, ["self"],
1468
arguments, {}, null, null),
1469
char,
1470
flag
1471
for(var i = 0, len = self.length; i < len; i++){
1472
char = self.charCodeAt(i)
1473
if(! printable[char]){
1474
return false
1475
}
1476
}
1477
return true
1478
}
1479
1480
str.isspace = function(self){
1481
/* Return true if there are only whitespace characters in the string and
1482
there is at least one character, false otherwise.
1483
1484
A character is whitespace if in the Unicode character database, either its
1485
general category is Zs ("Separator, space"), or its bidirectional class is
1486
one of WS, B, or S.*/
1487
var $ = $B.args("isspace", 1, {self: null}, ["self"],
1488
arguments, {}, null, null),
1489
char
1490
for(var i = 0, len = self.length; i < len; i++){
1491
char = self.charCodeAt(i)
1492
if(! unicode_tables.Zs[char] &&
1493
$B.unicode_bidi_whitespace.indexOf(char) == -1){
1494
return false
1495
}
1496
}
1497
return self.length > 0
1498
}
1499
1500
str.istitle = function(self){
1501
/* Return true if the string is a titlecased string and there is at least
1502
one character, for example uppercase characters may only follow uncased
1503
characters and lowercase characters only cased ones. Return false
1504
otherwise. */
1505
var $ = $B.args("istitle", 1, {self: null}, ["self"],
1506
arguments, {}, null, null)
1507
return self.length > 0 && str.title(self) == self
1508
}
1509
1510
str.isupper = function(self){
1511
/* Return true if all cased characters 4 in the string are lowercase and
1512
there is at least one cased character, false otherwise. */
1513
var $ = $B.args("islower", 1, {self: null}, ["self"],
1514
arguments, {}, null, null),
1515
has_cased = false,
1516
char
1517
1518
for(var i = 0, len = self.length; i < len; i++){
1519
char = self.charCodeAt(i)
1520
if(unicode_tables.Lu[char]){has_cased = true; continue}
1521
else if(unicode_tables.Ll[char] || unicode_tables.Lt[char]){
1539
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1540
"sequence item " + count + ": expected str instance, " +
1554
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1555
["self", "width", "fillchar"],
1556
arguments, {fillchar: " "}, null, null)
1562
str.lower = function(self){
1563
var $ = $B.args("lower", 1, {self: null}, ["self"],
1564
arguments, {}, null, null)
1565
return self.toLowerCase()
1566
}
1567
1569
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1570
arguments, {chars:_b_.None}, null, null)
1571
if($.chars === _b_.None){return $.self.trimLeft()}
1572
for(var i = 0; i < $.self.length; i++){
1573
if($.chars.indexOf($.self.charAt(i)) === -1){
1574
return $.self.substring(i)
1582
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1583
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1588
// If there is only one argument, it must be a dictionary mapping
1589
// Unicode ordinals (integers) or characters (strings of length 1) to
1590
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1592
if(! _b_.isinstance($.x, _b_.dict)){
1593
throw _b_.TypeError.$factory(
1594
"maketrans only argument must be a dict")
1597
for(var i = 0, len = items.length; i < len; i++){
1598
var k = items[i][0],
1599
v = items[i][1]
1600
if(! _b_.isinstance(k, _b_.int)){
1601
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1602
k = _b_.ord(k)
1603
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1606
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1607
throw _b_.TypeError.$factory("dictionary value " + v +
1615
// and in the resulting dictionary, each character in x will be mapped
1616
// to the character at the same position in y
1619
}else if($.x.length !== $.y.length){
1620
throw _b_.TypeError.$factory(
1621
"maketrans arguments must be strings or same length")
1627
if(! _b_.isinstance($.z, _b_.str)){
1628
throw _b_.TypeError.$factory(
1629
"maketrans third argument must be a string")
1651
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1652
arguments, {}, null, null)
1657
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1658
$.self.substring(i + $.sep.length)])
1659
}
1660
1661
str.removeprefix = function(){
1662
var $ = $B.args("removeprefix", 2, {self: null, prefix: null},
1663
["self", "prefix"], arguments, {}, null, null)
1664
if(!_b_.isinstance($.prefix, str)){
1665
throw _b_.ValueError.$factory("prefix should be str, not " +
1666
`'${$B.class_name($.prefix)}'`)
1667
}
1668
if(str.startswith($.self, $.prefix)){
1669
return $.self.substr($.prefix.length)
1670
}
1671
return $.self.substr(0)
1672
}
1673
1674
str.removesuffix = function(){
1675
var $ = $B.args("removesuffix", 2, {self: null, prefix: null},
1676
["self", "suffix"], arguments, {}, null, null)
1677
if(!_b_.isinstance($.suffix, str)){
1678
throw _b_.ValueError.$factory("suffix should be str, not " +
1679
`'${$B.class_name($.prefix)}'`)
1680
}
1681
if($.suffix.length > 0 && str.endswith($.self, $.suffix)){
1682
return $.self.substr(0, $.self.length - $.suffix.length)
1683
}
1684
return $.self.substr(0)
1685
}
1686
1687
function $re_escape(str){
1688
var specials = "[.*+?|()$^"
1689
for(var i = 0, len = specials.length; i < len; i++){
1690
var re = new RegExp("\\"+specials.charAt(i), "g")
1691
str = str.replace(re, "\\"+specials.charAt(i))
1692
}
1693
return str
1700
var $ = $B.args("replace", 4,
1701
{self: null, old: null, $$new: null, count: null},
1702
["self", "old", "$$new", "count"],
1703
arguments, {count: -1}, null, null),
1704
count = $.count,
1705
self = $.self,
1706
old = $.old,
1707
_new = $.$$new
1714
"' object cannot be interpreted as an integer")
1715
}else if(isinstance(count, _b_.float)){
1716
throw _b_.TypeError.$factory("integer argument expected, got float")
1717
}
1718
if(count == 0){return self}
1719
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1720
if(old == ""){
1721
if(_new == ""){return self}
1722
if(self == ""){return _new}
1723
var elts = self.split("")
1724
if(count > -1 && elts.length >= count){
1725
var rest = elts.slice(count).join("")
1726
return _new + elts.slice(0, count).join(_new) + rest
1727
}else{return _new + elts.join(_new) + _new}
1742
if(count < 0){count = res.length}
1743
while(count > 0){
1744
pos = res.indexOf(old, pos)
1745
if(pos < 0){break}
1746
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1747
pos = pos + _new.length
1748
count--
1754
// Return the highest index in the string where substring sub is found,
1755
// such that sub is contained within s[start:end]. Optional arguments
1757
if(arguments.length == 2 && typeof substr == "string"){
1758
return self.lastIndexOf(substr)
1759
}
1761
{self: null, sub: null, start: null, end: null},
1762
["self", "sub", "start", "end"],
1763
arguments, {start: 0, end: null}, null, null)
1775
for(var i = $.end - sublen; i >= $.start; i--){
1776
if($.self.substr(i, sublen) == $.sub){return i}
1783
var res = str.rfind.apply(null, arguments)
1784
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1789
var $ = $B.args("rjust",3,
1790
{self: null, width: null, fillchar: null},
1791
["self", "width", "fillchar"],
1792
arguments, {fillchar: " "}, null, null)
1800
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1801
arguments, {}, null, null)
1805
var items = str.partition(self, sep).reverse()
1806
for(var i = 0; i < items.length; i++){
1807
items[i] = items[i].split("").reverse().join("")
1813
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1814
["self", "sep", "maxsplit"], arguments,
1815
{sep: _b_.None, maxsplit: -1}, null, null),
1816
sep = $.sep
1819
var rev_str = reverse($.self),
1820
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1831
str.rstrip = function(self, x){
1832
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1833
arguments, {chars: _b_.None}, null, null)
1834
if($.chars === _b_.None){return $.self.trimRight()}
1836
if($.chars.indexOf($.self.charAt(j)) == -1){
1837
return $.self.substring(0, j + 1)
1844
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1845
["self", "sep", "maxsplit"], arguments,
1846
{sep: _b_.None, maxsplit: -1}, null, null),
1847
sep = $.sep,
1848
maxsplit = $.maxsplit,
1849
self = $.self,
1850
pos = 0
1851
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1852
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1853
if(sep === _b_.None){
1855
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1856
if(pos === self.length - 1){return [self]}
1857
var name = ""
1859
if(self.charAt(pos).search(/\s/) == -1){
1860
if(name == ""){name = self.charAt(pos)}
1861
else{name += self.charAt(pos)}
1881
var res = [],
1882
s = "",
1883
seplen = sep.length
1884
if(maxsplit == 0){return [self]}
1885
while(pos < self.length){
1886
if(self.substr(pos, seplen) == sep){
1904
str.splitlines = function(self) {
1905
var $ = $B.args('splitlines', 2, {self: null, keepends: null},
1906
['self','keepends'], arguments, {keepends: false},
1907
null, null)
1908
if(!_b_.isinstance($.keepends,[_b_.bool, _b_.int])){
1909
throw _b_.TypeError('integer argument expected, got '+
1912
var keepends = _b_.int.$factory($.keepends),
1913
res = [],
1914
self = $.self,
1915
start = 0,
1916
pos = 0
1917
if(!self.length){
1920
while (pos < self.length) {
1921
if(self.substr(pos, 2) == '\r\n'){
1922
res.push(self.slice(start, keepends ? pos + 2 : pos))
1923
start = pos = pos+2
1924
}else if(self[pos] == '\r' || self[pos] == '\n'){
1925
res.push(self.slice(start, keepends ? pos+1 : pos))
1926
start = pos = pos+1
1927
}else{
1928
pos++
1929
}
1930
}
1931
if(start < self.length){
1932
res.push(self.slice(start))
1933
}
1934
return res
1938
// Return True if string starts with the prefix, otherwise return False.
1939
// prefix can also be a tuple of prefixes to look for. With optional
1940
// start, test string beginning at that position. With optional end,
1942
var $ = $B.args("startswith", 4,
1943
{self: null, prefix: null, start: null, end: null},
1944
["self", "prefix", "start", "end"],
1945
arguments, {start: 0, end: null}, null, null)
1952
var s = $.self.substring($.start, $.end)
1953
for(var i = 0, len = prefixes.length; i < len; i++){
1964
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1965
arguments, {chars: _b_.None}, null, null)
1966
if($.chars === _b_.None){return $.self.trim()}
1967
for(var i = 0; i < $.self.length; i++){
1968
if($.chars.indexOf($.self.charAt(i)) == -1){
1969
break
1972
for(var j = $.self.length - 1; j >= i; j--){
1973
if($.chars.indexOf($.self.charAt(j)) == -1){
1974
break
1980
str.swapcase = function(self){
1981
var $ = $B.args("swapcase", 1, {self}, ["self"],
1982
arguments, {}, null, null),
1983
res = "",
1984
char
1985
1986
for(var i = 0, len = self.length; i < len; i++){
1987
char = self.charCodeAt(i)
1988
if(unicode_tables.Ll[char]){
1989
res += self.charAt(i).toUpperCase()
1990
}else if(unicode_tables.Lu[char]){
1991
res += self.charAt(i).toLowerCase()
1992
}else{
1993
res += self.charAt(i)
1994
}
1995
}
1996
return res
1997
}
1998
1999
str.title = function(self){
2000
var $ = $B.args("title", 1, {self}, ["self"],
2001
arguments, {}, null, null),
2002
state,
2003
char,
2004
res = ""
2005
for(var i = 0, len = self.length; i < len; i++){
2006
char = self.charCodeAt(i)
2007
if(unicode_tables.Ll[char]){
2008
if(! state){
2009
res += self.charAt(i).toUpperCase()
2010
state = "word"
2011
}else{
2012
res += self.charAt(i)
2013
}
2014
}else if(unicode_tables.Lu[char] || unicode_tables.Lt[char]){
2015
res += state ? self.charAt(i).toLowerCase() : self.charAt(i)
2016
state = "word"
2017
}else{
2018
state = null
2019
res += self.charAt(i)
2020
}
2021
}
2022
return res
2023
}
2024
2027
getitem = $B.$getattr(table, "__getitem__")
2028
for(var i = 0, len = self.length; i < len; i++){
2029
try{
2030
var repl = getitem(self.charCodeAt(i))
2031
if(repl !== _b_.None){
2032
if(typeof repl == "string"){
2033
res.push(repl)
2034
}else if(typeof repl == "number"){
2035
res.push(String.fromCharCode(repl))
2036
}
2045
str.upper = function(self){
2046
var $ = $B.args("upper", 1, {self: null}, ["self"],
2047
arguments, {}, null, null)
2048
return self.toUpperCase()
2049
}
2050
2053
["self", "width"], arguments, {}, null, null)
2054
if($.width <= self.length){return self}
2056
case "+":
2057
case "-":
2058
return self.charAt(0) +
2059
"0".repeat($.width - self.length) + self.substr(1)
2070
if(encoding !== undefined){
2071
// Arguments may be passed as keywords (cf. issue #1060)
2072
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
2073
["arg", "encoding", "errors"], arguments,
2074
{encoding: "utf-8", errors: "strict"}, null, null),
2075
encoding = $.encoding,
2076
errors = $.errors
2077
}
2088
// class or its subclasses, but the attribute __str__ of the
2089
// class metaclass (usually "type") or its subclasses (usually
2090
// "object")
2091
// The metaclass is the attribute __class__ of the class dictionary
2096
if(arg.__class__ && arg.__class__ === _b_.bytes &&
2097
encoding !== undefined){
2098
// str(bytes, encoding, errors) is equal to
2099
// bytes.decode(encoding, errors)
2102
// Implicit invocation of __str__ uses method __str__ on the class,
2103
// even if arg has an attribute __str__
2104
var klass = arg.__class__ || $B.get_class(arg)
2110
// if not better than object.__str__, try __repr__
2111
(arg.__class__ && arg.__class__ !== _b_.object &&
2112
method.$infos && method.$infos.__func__ === _b_.object.__str__)){
2113
var method = $B.$getattr(klass, "__repr__")
2119
if($B.debug > 1){console.log(err)}
2120
console.log("Warning - no method __str__ or __repr__, " +
2121
"default to toString", arg)
2128
if(cls === undefined){
2129
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
2153
var args = [],
2154
pos = 0
2155
if(arguments.length > 0){
2156
var args = [arguments[0].valueOf()],
2157
pos = 1
2158
for(var i = 1, len = arguments.length; i < len; i++){
2159
args[pos++] = arguments[i]
2175
// Function to parse the 2nd argument of format()
2176
$B.parse_format_spec = function(spec){
2179
var pos = 0,
2180
aligns = "<>=^",
2181
digits = "0123456789",
2182
types = "bcdeEfFgGnosxX%",
2184
if(align_pos != -1){
2185
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
2186
// If the second char is also an alignment specifier, the
2187
// first char is the fill value
2188
this.fill = spec.charAt(0)
2189
this.align = spec.charAt(1)
2190
pos = 2
2191
}else{
2192
// The first character defines alignment : fill defaults to ' '
2207
if(car == "+" || car == "-" || car == " "){
2208
this.sign = car
2209
pos++
2210
car = spec.charAt(pos)
2212
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
2213
if(car == "0"){
2222
while(car && digits.indexOf(car) > -1){
2223
if(this.width === undefined){this.width = car}
2224
else{this.width += car}
2225
pos++
2226
car = spec.charAt(pos)
2229
if(this.width === undefined && car == "{"){
2230
// Width is determined by a parameter
2231
var end_param_pos = spec.substr(pos).search("}")
2232
this.width = spec.substring(pos, end_param_pos)
2233
console.log("width", "[" + this.width + "]")
2234
pos += end_param_pos + 1
2235
}
2236
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
2237
if(car == "."){
2238
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
2239
throw _b_.ValueError.$factory(
2240
"Missing precision in format spec")
2242
this.precision = spec.charAt(pos + 1)
2243
pos += 2
2244
car = spec.charAt(pos)
2245
while(car && digits.indexOf(car) > -1){
2252
if(car && types.indexOf(car) > -1){
2253
this.type = car
2254
pos++
2255
car = spec.charAt(pos)
2256
}
2257
if(pos !== spec.length){
2263
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
2264
(this.align || "") +
2265
(this.sign || "") +
2266
(this.alternate ? "#" : "") +
2267
(this.sign_aware ? "0" : "") +
2268
(this.width || "") +
2269
(this.comma ? "," : "") +
2270
(this.precision ? "." + this.precision : "") +
2271
(this.type || "")
2276
if(fmt.width && s.length < fmt.width){
2277
var fill = fmt.fill || " ",
2278
align = fmt.align || "<",
2279
missing = fmt.width - s.length
2281
case "<":
2282
return s + fill.repeat(missing)
2283
case ">":
2284
return fill.repeat(missing) + s
2285
case "=":
2286
if("+-".indexOf(s.charAt(0)) > -1){
2287
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
2291
case "^":
2292
var left = parseInt(missing / 2)
2293
return fill.repeat(left) + s + fill.repeat(missing - left)
2306
$B.parse_fstring = function(string){
2307
// Parse a f-string
2308
var elts = [],
2309
pos = 0,
2333
}else{
2334
throw Error(" f-string: single '}' is not allowed")
2335
}
2336
}else{
2358
current += car
2359
i += 2
2360
}else{
2361
throw Error(" f-string: single '}' is not allowed")
2362
}
2363
}else{
2364
current += car
2365
i++
2366
}
2367
}
2369
}else if(ctype == "debug"){
2370
// after the equal sign, whitespace are ignored and the only
2371
// valid characters are } and :
2372
while(string.charAt(i) == " "){i++}
2373
if(string.charAt(i) == "}"){
2374
// end of debug expression
2375
elts.push(current)
2376
ctype = null
2377
current = ""
2378
pos = i + 1
2379
}
2380
}else{
2381
// End of expression is the } matching the opening {
2382
// There may be nested braces
2383
var i = pos,
2384
nb_braces = 1,
2406
// backslash is not allowed in expressions
2407
throw Error("f-string expression part cannot include a" +
2408
" backslash")
2415
throw Error("f-string: invalid conversion character:" +
2416
" expected 's', 'r', or 'a'")
2417
}else{
2431
if(string.substr(i, 3) == '"""'){
2432
var end = string.indexOf('"""', i + 3)
2433
if(end == -1){
2434
throw Error("f-string: unterminated string")
2435
}else{
2436
var trs = string.substring(i, end + 3)
2437
trs = trs.replace("\n", "\\n\\")
2442
var end = string.indexOf('"', i + 1)
2443
if(end == -1){
2444
throw Error("f-string: unterminated string")
2445
}else{
2446
current.expression += string.substring(i, end + 1)
2447
i = end + 1
2456
var ce = current.expression,
2457
last_char = ce.charAt(ce.length - 1),
2458
last_char_re = ('()'.indexOf(last_char) > -1 ? "\\" : "") + last_char
2465
}else{
2466
// add debug string
2467
tail = car
2468
while(string.charAt(i + 1).match(/\s/)){
2469
tail += string.charAt(i + 1)
2470
i++
2471
}
2472
elts.push(current.expression + tail)
2473
// remove trailing whitespace from expression
2474
while(ce.match(/\s$/)){
2475
ce = ce.substr(0, ce.length - 1)
2476
}
2477
current.expression = ce
2478
ctype = "debug"
2479
i++
2480
}
2495
// Class for strings with surrogate pairs. We can't rely on Javascript
2496
// strings in this case because they don't count characters like Python
2497
2498
var surrogate = str.$surrogate = $B.make_class("surrogate_string", function(s){
2499
// create an instance of str subclass for strings with surrogate pairs
2500
var items = []
2501
for(var i = 0, len = s.length; i < len; i++){
2502
var code = s.charCodeAt(i)
2503
if(code >= 0xD800 && code <= 0xDBFF){
2504
i++
2505
var low = s.charCodeAt(i)
2506
code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000
2507
}
2508
items.push(String.fromCodePoint(code))
2509
}
2510
return {
2511
__class__: str.$surrogate,
2512
items: items
2513
}
2514
})
2515
2516
surrogate.__mro__ = [str, object]
2517
2518
surrogate.__contains__ = function(self, other){
2519
return str.__contains__(self.items.join(''), other)
2520
}
2521
2522
surrogate.__getitem__ = function(self, arg){
2523
if(isinstance(arg, _b_.int)){
2524
var pos = arg
2525
if(arg < 0){
2526
pos += self.items.length
2527
}
2528
if(pos >= 0 && pos < self.items.length){
2529
if(self.items[pos].length == 2){
2530
return surrogate.$factory(self.items[pos])
2531
}
2532
return self.items[pos]
2533
}
2534
throw _b_.IndexError.$factory("string index out of range")
2535
}
2536
if(isinstance(arg, slice)) {
2537
var s = _b_.slice.$conv_for_seq(arg, self.items.length),
2538
start = s.start,
2539
stop = s.stop,
2540
step = s.step
2541
var res = "",
2542
i = null
2543
if(step > 0){
2544
if(stop <= start){return ""}
2545
for(var i = start; i < stop; i += step){
2546
res += self.items[i]
2547
}
2548
}else{
2549
if(stop >= start){return ''}
2550
for(var i = start; i > stop; i += step){
2551
res += self.items[i]
2552
}
2553
}
2554
return res
2555
}
2556
if(isinstance(arg, _b_.bool)){
2557
return surrogate.__getitem__(self, _b_.int.$factory(arg))
2558
}
2559
throw _b_.TypeError.$factory("string indices must be integers")
2560
}
2561
2562
surrogate.__hash__ = function(self){
2563
return str.__hash__(self.items.join(''))
2564
}
2565
2566
surrogate.__iter__ = function(self){
2567
return str_iterator.$factory(self.items)
2568
}
2569
2570
surrogate.__len__ = function(self){
2571
return self.items.length
2572
}
2573
2574
surrogate.__repr__ = function(self){
2575
return str.__repr__(self.items.join(''))
2576
}
2577
2578
surrogate.__str__ = function(self){
2579
return str.__str__(self.items.join(''))
2580
}
2581
2582
$B.set_func_names(surrogate, "builtins")
2583
2584