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 22, 2020
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Nov 22, 2020
Apr 2, 2019
Sep 27, 2020
Sep 27, 2020
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
Nov 30, 2020
Oct 13, 2019
Apr 25, 2020
Newer
100644
2602 lines (2388 sloc)
82.8 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
715
if(self === undefined){
716
throw _b_.TypeError.$factory(
717
"not enough arguments for format string")
744
throw _b_.ValueError.$factory(
745
"unsupported format character '" + invalid_char +
746
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
747
") at index " + newpos)
748
}else if(err.name === "NotANumber"){
749
var try_char = s[newpos],
750
cls = self.__class__
751
if(!cls){
752
if(typeof(self) === "string"){
753
cls = "str"
754
}else{
760
throw _b_.TypeError.$factory("%" + try_char +
761
" format: a number is required, not " + cls)
762
}else{
794
}while(pos < length)
795
796
if(argpos !== null){
797
if(args.length > argpos){
798
throw _b_.TypeError.$factory(
799
"not enough arguments for format string")
800
}else if(args.length < argpos){
801
throw _b_.TypeError.$factory(
802
"not all arguments converted during string formatting")
804
}else if(nbph == 0){
805
throw _b_.TypeError.$factory(
806
"not all arguments converted during string formatting")
814
var $ = $B.args("__mul__", 2, {self: null, other: null},
815
["self", "other"], arguments, {}, null, null)
816
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
817
"Can't multiply sequence by non-int of type '" +
829
res = self.replace(/\\/g, "\\\\")
830
// special cases
831
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
832
replace(new RegExp("\b", "g"), "\\x08").
834
replace(new RegExp("\f", "g"), "\\x0c").
835
replace(new RegExp("\n", "g"), "\\n").
836
replace(new RegExp("\r", "g"), "\\r").
837
replace(new RegExp("\t", "g"), "\\t")
839
// Replace unassigned code point by \uabcd...
840
// Uses function $B.is_unicode_cn() in unicode_data.js
841
var repl = ''
842
for(var i = 0; i < res.length; i++){
843
if($B.is_unicode_cn(res.codePointAt(i))){
844
var s = res.codePointAt(i).toString(16)
845
while(s.length < 4){
846
s = '0' + s
847
}
848
repl += '\\u' + s
849
}else{
850
repl += res.charAt(i)
851
}
852
}
853
res = repl
854
if(res.search('"') == -1 && res.search("'") == -1){
855
return "'" + res + "'"
856
}else if(self.search('"') == -1){
857
return '"' + res + '"'
858
}
859
var qesc = new RegExp("'", "g") // to escape single quote
860
res = "'" + res.replace(qesc, "\\'") + "'"
864
str.__setitem__ = function(self, attr, value){
865
throw _b_.TypeError.$factory(
866
"'str' object does not support item assignment")
868
var combining = []
869
for(var cp = 0x300; cp <= 0x36F; cp++){
870
combining.push(String.fromCharCode(cp))
871
}
872
var combining_re = new RegExp("(" + combining.join("|") + ")")
884
$comp_func += "" // source code
885
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
894
var $notimplemented = function(self, other){
895
throw NotImplementedError.$factory(
896
"OPERATOR not implemented for class str")
899
str.capitalize = function(self){
900
var $ = $B.args("capitalize", 1, {self}, ["self"],
901
arguments, {}, null, null)
902
if(self.length == 0){return ""}
903
return self.charAt(0).toUpperCase() + self.substr(1)
904
}
905
906
str.casefold = function(self){
907
var $ = $B.args("casefold", 1, {self}, ["self"],
908
arguments, {}, null, null),
909
res = "",
910
char,
911
cf
912
for(var i = 0, len = self.length; i < len; i++){
913
char = self.charCodeAt(i)
914
cf = $B.unicode_casefold[char]
915
if(cf){
916
cf.forEach(function(cp){
917
res += String.fromCharCode(cp)
918
})
919
}else{
920
res += self.charAt(i).toLowerCase()
921
}
922
}
923
return res
924
}
926
str.center = function(){
927
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
928
["self", "width", "fillchar"],
929
arguments, {fillchar:" "}, null, null),
930
self = $.self
942
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
943
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
951
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
952
else{_slice = _b_.slice.$factory($.start, $.self.length)}
957
if($.sub.length == 0){
958
if($.start == $.self.length){return 1}
959
else if(substr.length == 0){return 0}
960
return substr.length + 1
962
var n = 0,
963
pos = 0
964
while(pos < substr.length){
965
pos = substr.indexOf($.sub, pos)
966
if(pos >= 0){n++; pos += $.sub.length}
967
else{break}
972
str.encode = function(){
973
var $ = $B.args("encode", 3, {self: null, encoding: null, errors: null},
974
["self", "encoding", "errors"], arguments,
975
{encoding: "utf-8", errors: "strict"}, null, null)
976
if($.encoding == "rot13" || $.encoding == "rot_13"){
981
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
982
res += String.fromCharCode(String.charCodeAt(char) + 13)
983
}else if(("m" < char && char <= "z") ||
984
("M" < char && char <= "Z")){
985
res += String.fromCharCode(String.charCodeAt(char) - 13)
994
// Return True if the string ends with the specified suffix, otherwise
995
// return False. suffix can also be a tuple of suffixes to look for.
996
// With optional start, test beginning at that position. With optional
1000
["self", "suffix", "start", "end"],
1001
arguments, {start: 0, end: null}, null, null)
1008
var s = $.self.substring($.start, $.end)
1009
for(var i = 0, len = suffixes.length; i < len; i++){
1013
if(suffix.length <= s.length &&
1014
s.substr(s.length - suffix.length) == suffix){return true}
1020
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
1021
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
1022
var s = $B.$GetInt($.tabsize),
1023
col = 0,
1024
pos = 0,
1025
res = ""
1026
if(s == 1){return self.replace(/\t/g," ")}
1027
while(pos < self.length){
1035
res += car
1036
col = 0
1037
break
1038
default:
1039
res += car
1040
col++
1041
break
1042
}
1043
pos++
1044
}
1050
// Return the lowest index in the string where substring sub is found,
1051
// such that sub is contained in the slice s[start:end]. Optional
1052
// arguments start and end are interpreted as in slice notation.
1055
{self: null, sub: null, start: null, end: null},
1056
["self", "sub", "start", "end"],
1057
arguments, {start: 0, end: null}, null, null)
1061
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1062
throw _b_.TypeError.$factory("slice indices must be " +
1063
"integers or None or have an __index__ method")}
1064
// Can't use string.substring(start, end) because if end < start,
1065
// Javascript transforms it into substring(end, start)...
1066
var s = ""
1067
for(var i = $.start; i < $.end; i++){
1068
s += $.self.charAt(i)
1069
}
1071
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1072
if(s.length + $.sub.length == 0){return -1}
1074
var last_search = s.length - $.sub.length
1075
for(var i = 0; i <= last_search; i++){
1076
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1087
// a.x[z]!r:...
1088
// the object has attributes :
1089
// - name : "a"
1090
// - name_ext : [".x", "[z]"]
1091
// - conv : r
1092
// - spec : rest of string after :
1100
// No : in the string : it only contains a name
1101
name = fmt_string
1102
}else{
1103
// name is before the first ":"
1104
// spec (the format specification) is after
1105
name = elts[0]
1109
var elts = name.split("!")
1110
if(elts.length > 1){
1111
name = elts[0]
1112
conv = elts[1] // conversion flag
1116
// "name' may be a subscription or attribute
1117
// Put these "extensions" in the list "name_ext"
1118
function name_repl(match){
1119
name_ext.push(match)
1121
}
1122
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1123
name = name.replace(name_ext_re, name_repl)
1124
}
1131
// Parse self to detect formatting instructions
1132
// Create a list "parts" made of sections of the string :
1133
// - elements of even rank are literal text
1134
// - elements of odd rank are "format objects", built from the
1135
// format strings in self (of the form {...})
1146
text += "{"
1147
pos += 2
1148
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1155
// Store current literal text
1156
parts.push(text)
1157
1158
// Search the end of the format string, ie the } closing the
1159
// opening {. Since the string can contain other pairs {} for
1160
// nested formatting, an integer nb is incremented for each { and
1161
// decremented for each } ; the end of the format string is
1162
// reached when nb == 0
1163
var end = pos + 1,
1164
nb = 1
1165
while(end < _len){
1166
if(self.charAt(end) == "{"){nb++; end++}
1167
else if(self.charAt(end) == "}"){
1168
nb--; end++
1169
if(nb == 0){
1174
var fmt_obj = $B.parse_format(fmt_string)
1175
fmt_obj.raw_name = fmt_obj.name
1176
fmt_obj.raw_spec = fmt_obj.spec
1215
// Special management of keyword arguments if str.format is called by
1216
// str.format_map(mapping) : the argument "mapping" might not be a
1217
// dictionary
1218
var last_arg = $B.last(arguments)
1219
if(last_arg.$nat == "mapping"){
1220
var mapping = last_arg.mapping,
1221
getitem = $B.$getattr(mapping, "__getitem__")
1222
// Get the rest of the arguments
1223
var args = []
1224
for(var i = 0, len = arguments.length - 1; i < len; i++){
1225
args.push(arguments[i])
1226
}
1227
var $ = $B.args("format", 1, {self: null}, ["self"],
1228
args, {}, "$args", null)
1229
}else{
1230
var $ = $B.args("format", 1, {self: null}, ["self"],
1231
arguments, {}, "$args", "$kw"),
1232
mapping = $.$kw, // dictionary
1233
getitem = function(key){
1234
return _b_.dict.$getitem(mapping, key)
1235
}
1236
}
1249
1250
if(fmt.spec !== undefined){
1251
// "spec" may contain "nested replacement fields"
1252
// In this case, evaluate them using the positional
1253
// or keyword arguments passed to format()
1254
function replace_nested(name, key){
1255
if(/\d+/.exec(key)){
1256
// If key is numeric, search in positional
1257
// arguments
1258
return _b_.tuple.__getitem__($.$args,
1259
parseInt(key))
1260
}else{
1261
// Else try in keyword arguments
1262
return _b_.dict.__getitem__($.$kw, key)
1263
}
1264
}
1265
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1266
replace_nested)
1267
}
1269
// Numerical reference : use positional arguments
1270
var pos = parseInt(fmt.name),
1280
// Attribute
1281
value = _b_.getattr(value, ext.substr(1))
1282
}else{
1283
// Subscription
1286
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1287
value = _b_.getattr(value, "__getitem__")(key)
1291
// If the conversion flag is set, first call a function to convert
1292
// the value
1293
if(fmt.conv == "a"){value = _b_.ascii(value)}
1294
else if(fmt.conv == "r"){value = _b_.repr(value)}
1295
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1308
str.format_map = function(self, mapping){
1309
var $ = $B.args("format_map", 2, {self: null, mapping: null},
1310
['self', 'mapping'], arguments, {}, null, null)
1311
return str.format(self, {$nat: 'mapping', mapping})
1322
/* Return true if the string is empty or all characters in the string are
1323
ASCII, false otherwise. ASCII characters have code points in the range
1324
U+0000-U+007F. */
1325
for(var i = 0, len = self.length; i < len; i++){
1326
if(self.charCodeAt(i) > 127){return false}
1327
}
1328
return true
1329
}
1330
1331
str.isalnum = function(self){
1332
/* Return true if all characters in the string are alphanumeric and there
1333
is at least one character, false otherwise. A character c is alphanumeric
1334
if one of the following returns True: c.isalpha(), c.isdecimal(),
1335
c.isdigit(), or c.isnumeric(). */
1336
var $ = $B.args("isalnum", 1, {self: null}, ["self"],
1337
arguments, {}, null, null),
1338
char
1339
for(var i = 0, len = self.length; i < len; i++){
1340
char = self.charCodeAt(i)
1341
if(unicode_tables.Ll[char] ||
1342
unicode_tables.Lu[char] ||
1343
unicode_tables.Lm[char] ||
1344
unicode_tables.Lt[char] ||
1345
unicode_tables.Lo[char] ||
1346
unicode_tables.Nd[char] ||
1347
unicode_tables.digits[char] ||
1348
unicode_tables.numeric[char]){
1349
continue
1350
}
1351
return false
1352
}
1353
return true
1354
}
1355
1356
str.isalpha = function(self){
1357
/* Return true if all characters in the string are alphabetic and there is
1358
at least one character, false otherwise. Alphabetic characters are those
1359
characters defined in the Unicode character database as "Letter", i.e.,
1360
those with general category property being one of "Lm", "Lt", "Lu", "Ll",
1361
or "Lo". */
1362
var $ = $B.args("isalpha", 1, {self: null}, ["self"],
1363
arguments, {}, null, null),
1364
char
1365
for(var i = 0, len = self.length; i < len; i++){
1366
char = self.charCodeAt(i)
1367
if(unicode_tables.Ll[char] ||
1368
unicode_tables.Lu[char] ||
1369
unicode_tables.Lm[char] ||
1370
unicode_tables.Lt[char] ||
1371
unicode_tables.Lo[char]){
1372
continue
1373
}
1374
return false
1375
}
1376
return true
1377
}
1378
1379
str.isdecimal = function(self){
1380
/* Return true if all characters in the string are decimal characters and
1381
there is at least one character, false otherwise. Decimal characters are
1382
those that can be used to form numbers in base 10, e.g. U+0660,
1383
ARABIC-INDIC DIGIT ZERO. Formally a decimal character is a character in
1384
the Unicode General Category "Nd". */
1385
var $ = $B.args("isdecimal", 1, {self: null}, ["self"],
1386
arguments, {}, null, null),
1387
char
1388
for(var i = 0, len = self.length; i < len; i++){
1389
char = self.charCodeAt(i)
1390
if(! unicode_tables.Nd[char]){
1391
return false
1392
}
1393
}
1394
return self.length > 0
1395
}
1396
1397
str.isdigit = function(self){
1398
/* Return true if all characters in the string are digits and there is at
1399
least one character, false otherwise. */
1400
var $ = $B.args("isdigit", 1, {self: null}, ["self"],
1401
arguments, {}, null, null),
1402
char
1403
for(var i = 0, len = self.length; i < len; i++){
1404
char = self.charCodeAt(i)
1405
if(! unicode_tables.digits[char]){
1406
return false
1407
}
1408
}
1409
return self.length > 0
1410
}
1411
1412
str.isidentifier = function(self){
1413
/* Return true if the string is a valid identifier according to the
1414
language definition. */
1415
var $ = $B.args("isidentifier", 1, {self: null}, ["self"],
1416
arguments, {}, null, null),
1417
char
1418
if(self.length == 0){return false}
1419
else if(unicode_tables.XID_Start[self.charCodeAt(0)] === undefined){
1420
return false
1421
}else{
1422
for(var i = 1, len = self.length; i < len; i++){
1423
if(unicode_tables.XID_Continue[self.charCodeAt(i)] === undefined){
1424
return false
1425
}
1426
}
1427
}
1428
return true
1429
}
1430
1431
str.islower = function(self){
1432
/* Return true if all cased characters 4 in the string are lowercase and
1433
there is at least one cased character, false otherwise. */
1434
var $ = $B.args("islower", 1, {self: null}, ["self"],
1435
arguments, {}, null, null),
1436
has_cased = false,
1437
char
1438
1439
for(var i = 0, len = self.length; i < len; i++){
1440
char = self.charCodeAt(i)
1441
if(unicode_tables.Ll[char]){has_cased = true; continue}
1442
else if(unicode_tables.Lu[char] || unicode_tables.Lt[char]){
1443
return false
1444
}
1445
}
1446
return has_cased
1447
}
1448
1449
str.isnumeric = function(self){
1450
/* Return true if all characters in the string are numeric characters, and
1451
there is at least one character, false otherwise. Numeric characters
1452
include digit characters, and all characters that have the Unicode numeric
1453
value property, e.g. U+2155, VULGAR FRACTION ONE FIFTH. Formally, numeric
1454
characters are those with the property value Numeric_Type=Digit,
1455
Numeric_Type=Decimal or Numeric_Type=Numeric.*/
1456
var $ = $B.args("isnumeric", 1, {self: null}, ["self"],
1457
arguments, {}, null, null)
1458
for(var i = 0, len = self.length; i < len; i++){
1459
if(! unicode_tables.numeric[self.charCodeAt(i)]){
1460
return false
1461
}
1462
}
1463
return self.length > 0
1464
}
1465
1466
var unprintable = {},
1467
unprintable_gc = ['Cc', 'Cf', 'Co', 'Cs','Zl', 'Zp', 'Zs']
1468
1469
str.isprintable = function(self){
1470
/* Return true if all characters in the string are printable or the string
1471
is empty, false otherwise. Nonprintable characters are those characters
1472
defined in the Unicode character database as "Other" or "Separator",
1473
excepting the ASCII space (0x20) which is considered printable. */
1474
1475
// Set unprintable if not set yet
1476
if(Object.keys(unprintable).length == 0){
1477
for(var i = 0; i < unprintable_gc.length; i++){
1478
var table = unicode_tables[unprintable_gc[i]]
1489
return false
1490
}
1491
}
1492
return true
1493
}
1494
1495
str.isspace = function(self){
1496
/* Return true if there are only whitespace characters in the string and
1497
there is at least one character, false otherwise.
1498
1499
A character is whitespace if in the Unicode character database, either its
1500
general category is Zs ("Separator, space"), or its bidirectional class is
1501
one of WS, B, or S.*/
1502
var $ = $B.args("isspace", 1, {self: null}, ["self"],
1503
arguments, {}, null, null),
1504
char
1505
for(var i = 0, len = self.length; i < len; i++){
1506
char = self.charCodeAt(i)
1507
if(! unicode_tables.Zs[char] &&
1508
$B.unicode_bidi_whitespace.indexOf(char) == -1){
1509
return false
1510
}
1511
}
1512
return self.length > 0
1513
}
1514
1515
str.istitle = function(self){
1516
/* Return true if the string is a titlecased string and there is at least
1517
one character, for example uppercase characters may only follow uncased
1518
characters and lowercase characters only cased ones. Return false
1519
otherwise. */
1520
var $ = $B.args("istitle", 1, {self: null}, ["self"],
1521
arguments, {}, null, null)
1522
return self.length > 0 && str.title(self) == self
1523
}
1524
1525
str.isupper = function(self){
1526
/* Return true if all cased characters 4 in the string are lowercase and
1527
there is at least one cased character, false otherwise. */
1528
var $ = $B.args("islower", 1, {self: null}, ["self"],
1529
arguments, {}, null, null),
1530
has_cased = false,
1531
char
1532
1533
for(var i = 0, len = self.length; i < len; i++){
1534
char = self.charCodeAt(i)
1535
if(unicode_tables.Lu[char]){has_cased = true; continue}
1536
else if(unicode_tables.Ll[char] || unicode_tables.Lt[char]){
1554
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1555
"sequence item " + count + ": expected str instance, " +
1569
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1570
["self", "width", "fillchar"],
1571
arguments, {fillchar: " "}, null, null)
1577
str.lower = function(self){
1578
var $ = $B.args("lower", 1, {self: null}, ["self"],
1579
arguments, {}, null, null)
1580
return self.toLowerCase()
1581
}
1582
1584
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1585
arguments, {chars:_b_.None}, null, null)
1586
if($.chars === _b_.None){return $.self.trimLeft()}
1587
for(var i = 0; i < $.self.length; i++){
1588
if($.chars.indexOf($.self.charAt(i)) === -1){
1589
return $.self.substring(i)
1597
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1598
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1603
// If there is only one argument, it must be a dictionary mapping
1604
// Unicode ordinals (integers) or characters (strings of length 1) to
1605
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1607
if(! _b_.isinstance($.x, _b_.dict)){
1608
throw _b_.TypeError.$factory(
1609
"maketrans only argument must be a dict")
1612
for(var i = 0, len = items.length; i < len; i++){
1613
var k = items[i][0],
1614
v = items[i][1]
1615
if(! _b_.isinstance(k, _b_.int)){
1616
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1617
k = _b_.ord(k)
1618
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1621
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1622
throw _b_.TypeError.$factory("dictionary value " + v +
1630
// and in the resulting dictionary, each character in x will be mapped
1631
// to the character at the same position in y
1634
}else if($.x.length !== $.y.length){
1635
throw _b_.TypeError.$factory(
1636
"maketrans arguments must be strings or same length")
1642
if(! _b_.isinstance($.z, _b_.str)){
1643
throw _b_.TypeError.$factory(
1644
"maketrans third argument must be a string")
1666
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1667
arguments, {}, null, null)
1672
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1673
$.self.substring(i + $.sep.length)])
1674
}
1675
1676
str.removeprefix = function(){
1677
var $ = $B.args("removeprefix", 2, {self: null, prefix: null},
1678
["self", "prefix"], arguments, {}, null, null)
1679
if(!_b_.isinstance($.prefix, str)){
1680
throw _b_.ValueError.$factory("prefix should be str, not " +
1681
`'${$B.class_name($.prefix)}'`)
1682
}
1683
if(str.startswith($.self, $.prefix)){
1684
return $.self.substr($.prefix.length)
1685
}
1686
return $.self.substr(0)
1687
}
1688
1689
str.removesuffix = function(){
1690
var $ = $B.args("removesuffix", 2, {self: null, prefix: null},
1691
["self", "suffix"], arguments, {}, null, null)
1692
if(!_b_.isinstance($.suffix, str)){
1693
throw _b_.ValueError.$factory("suffix should be str, not " +
1694
`'${$B.class_name($.prefix)}'`)
1695
}
1696
if($.suffix.length > 0 && str.endswith($.self, $.suffix)){
1697
return $.self.substr(0, $.self.length - $.suffix.length)
1698
}
1699
return $.self.substr(0)
1700
}
1701
1702
function $re_escape(str){
1703
var specials = "[.*+?|()$^"
1704
for(var i = 0, len = specials.length; i < len; i++){
1705
var re = new RegExp("\\"+specials.charAt(i), "g")
1706
str = str.replace(re, "\\"+specials.charAt(i))
1707
}
1708
return str
1715
var $ = $B.args("replace", 4,
1716
{self: null, old: null, $$new: null, count: null},
1717
["self", "old", "$$new", "count"],
1718
arguments, {count: -1}, null, null),
1719
count = $.count,
1720
self = $.self,
1721
old = $.old,
1722
_new = $.$$new
1729
"' object cannot be interpreted as an integer")
1730
}else if(isinstance(count, _b_.float)){
1731
throw _b_.TypeError.$factory("integer argument expected, got float")
1732
}
1733
if(count == 0){return self}
1734
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1735
if(old == ""){
1736
if(_new == ""){return self}
1737
if(self == ""){return _new}
1738
var elts = self.split("")
1739
if(count > -1 && elts.length >= count){
1740
var rest = elts.slice(count).join("")
1741
return _new + elts.slice(0, count).join(_new) + rest
1742
}else{return _new + elts.join(_new) + _new}
1757
if(count < 0){count = res.length}
1758
while(count > 0){
1759
pos = res.indexOf(old, pos)
1760
if(pos < 0){break}
1761
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1762
pos = pos + _new.length
1763
count--
1769
// Return the highest index in the string where substring sub is found,
1770
// such that sub is contained within s[start:end]. Optional arguments
1772
if(arguments.length == 2 && typeof substr == "string"){
1773
return self.lastIndexOf(substr)
1774
}
1776
{self: null, sub: null, start: null, end: null},
1777
["self", "sub", "start", "end"],
1778
arguments, {start: 0, end: null}, null, null)
1790
for(var i = $.end - sublen; i >= $.start; i--){
1791
if($.self.substr(i, sublen) == $.sub){return i}
1798
var res = str.rfind.apply(null, arguments)
1799
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1804
var $ = $B.args("rjust",3,
1805
{self: null, width: null, fillchar: null},
1806
["self", "width", "fillchar"],
1807
arguments, {fillchar: " "}, null, null)
1815
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1816
arguments, {}, null, null)
1820
var items = str.partition(self, sep).reverse()
1821
for(var i = 0; i < items.length; i++){
1822
items[i] = items[i].split("").reverse().join("")
1828
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1829
["self", "sep", "maxsplit"], arguments,
1830
{sep: _b_.None, maxsplit: -1}, null, null),
1831
sep = $.sep
1834
var rev_str = reverse($.self),
1835
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1846
str.rstrip = function(self, x){
1847
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1848
arguments, {chars: _b_.None}, null, null)
1849
if($.chars === _b_.None){return $.self.trimRight()}
1851
if($.chars.indexOf($.self.charAt(j)) == -1){
1852
return $.self.substring(0, j + 1)
1859
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1860
["self", "sep", "maxsplit"], arguments,
1861
{sep: _b_.None, maxsplit: -1}, null, null),
1862
sep = $.sep,
1863
maxsplit = $.maxsplit,
1864
self = $.self,
1865
pos = 0
1866
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1867
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1868
if(sep === _b_.None){
1870
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1871
if(pos === self.length - 1){return [self]}
1872
var name = ""
1874
if(self.charAt(pos).search(/\s/) == -1){
1875
if(name == ""){name = self.charAt(pos)}
1876
else{name += self.charAt(pos)}
1896
var res = [],
1897
s = "",
1898
seplen = sep.length
1899
if(maxsplit == 0){return [self]}
1900
while(pos < self.length){
1901
if(self.substr(pos, seplen) == sep){
1919
str.splitlines = function(self) {
1920
var $ = $B.args('splitlines', 2, {self: null, keepends: null},
1921
['self','keepends'], arguments, {keepends: false},
1922
null, null)
1923
if(!_b_.isinstance($.keepends,[_b_.bool, _b_.int])){
1924
throw _b_.TypeError('integer argument expected, got '+
1927
var keepends = _b_.int.$factory($.keepends),
1928
res = [],
1929
self = $.self,
1930
start = 0,
1931
pos = 0
1932
if(!self.length){
1935
while (pos < self.length) {
1936
if(self.substr(pos, 2) == '\r\n'){
1937
res.push(self.slice(start, keepends ? pos + 2 : pos))
1938
start = pos = pos+2
1939
}else if(self[pos] == '\r' || self[pos] == '\n'){
1940
res.push(self.slice(start, keepends ? pos+1 : pos))
1941
start = pos = pos+1
1942
}else{
1943
pos++
1944
}
1945
}
1946
if(start < self.length){
1947
res.push(self.slice(start))
1948
}
1949
return res
1953
// Return True if string starts with the prefix, otherwise return False.
1954
// prefix can also be a tuple of prefixes to look for. With optional
1955
// start, test string beginning at that position. With optional end,
1957
var $ = $B.args("startswith", 4,
1958
{self: null, prefix: null, start: null, end: null},
1959
["self", "prefix", "start", "end"],
1960
arguments, {start: 0, end: null}, null, null)
1967
var s = $.self.substring($.start, $.end)
1968
for(var i = 0, len = prefixes.length; i < len; i++){
1979
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1980
arguments, {chars: _b_.None}, null, null)
1981
if($.chars === _b_.None){return $.self.trim()}
1982
for(var i = 0; i < $.self.length; i++){
1983
if($.chars.indexOf($.self.charAt(i)) == -1){
1984
break
1987
for(var j = $.self.length - 1; j >= i; j--){
1988
if($.chars.indexOf($.self.charAt(j)) == -1){
1989
break
1995
str.swapcase = function(self){
1996
var $ = $B.args("swapcase", 1, {self}, ["self"],
1997
arguments, {}, null, null),
1998
res = "",
1999
char
2000
2001
for(var i = 0, len = self.length; i < len; i++){
2002
char = self.charCodeAt(i)
2003
if(unicode_tables.Ll[char]){
2004
res += self.charAt(i).toUpperCase()
2005
}else if(unicode_tables.Lu[char]){
2006
res += self.charAt(i).toLowerCase()
2007
}else{
2008
res += self.charAt(i)
2009
}
2010
}
2011
return res
2012
}
2013
2014
str.title = function(self){
2015
var $ = $B.args("title", 1, {self}, ["self"],
2016
arguments, {}, null, null),
2017
state,
2018
char,
2019
res = ""
2020
for(var i = 0, len = self.length; i < len; i++){
2021
char = self.charCodeAt(i)
2022
if(unicode_tables.Ll[char]){
2023
if(! state){
2024
res += self.charAt(i).toUpperCase()
2025
state = "word"
2026
}else{
2027
res += self.charAt(i)
2028
}
2029
}else if(unicode_tables.Lu[char] || unicode_tables.Lt[char]){
2030
res += state ? self.charAt(i).toLowerCase() : self.charAt(i)
2031
state = "word"
2032
}else{
2033
state = null
2034
res += self.charAt(i)
2035
}
2036
}
2037
return res
2038
}
2039
2042
getitem = $B.$getattr(table, "__getitem__")
2043
for(var i = 0, len = self.length; i < len; i++){
2044
try{
2045
var repl = getitem(self.charCodeAt(i))
2046
if(repl !== _b_.None){
2047
if(typeof repl == "string"){
2048
res.push(repl)
2049
}else if(typeof repl == "number"){
2050
res.push(String.fromCharCode(repl))
2051
}
2060
str.upper = function(self){
2061
var $ = $B.args("upper", 1, {self: null}, ["self"],
2062
arguments, {}, null, null)
2063
return self.toUpperCase()
2064
}
2065
2068
["self", "width"], arguments, {}, null, null)
2069
if($.width <= self.length){return self}
2071
case "+":
2072
case "-":
2073
return self.charAt(0) +
2074
"0".repeat($.width - self.length) + self.substr(1)
2085
if(encoding !== undefined){
2086
// Arguments may be passed as keywords (cf. issue #1060)
2087
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
2088
["arg", "encoding", "errors"], arguments,
2089
{encoding: "utf-8", errors: "strict"}, null, null),
2090
encoding = $.encoding,
2091
errors = $.errors
2092
}
2103
// class or its subclasses, but the attribute __str__ of the
2104
// class metaclass (usually "type") or its subclasses (usually
2105
// "object")
2106
// The metaclass is the attribute __class__ of the class dictionary
2111
if(arg.__class__ && arg.__class__ === _b_.bytes &&
2112
encoding !== undefined){
2113
// str(bytes, encoding, errors) is equal to
2114
// bytes.decode(encoding, errors)
2117
// Implicit invocation of __str__ uses method __str__ on the class,
2118
// even if arg has an attribute __str__
2119
var klass = arg.__class__ || $B.get_class(arg)
2125
// if not better than object.__str__, try __repr__
2126
(arg.__class__ && arg.__class__ !== _b_.object &&
2127
method.$infos && method.$infos.__func__ === _b_.object.__str__)){
2128
var method = $B.$getattr(klass, "__repr__")
2134
if($B.debug > 1){console.log(err)}
2135
console.log("Warning - no method __str__ or __repr__, " +
2136
"default to toString", arg)
2143
if(cls === undefined){
2144
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
2168
var args = [],
2169
pos = 0
2170
if(arguments.length > 0){
2171
var args = [arguments[0].valueOf()],
2172
pos = 1
2173
for(var i = 1, len = arguments.length; i < len; i++){
2174
args[pos++] = arguments[i]
2191
// Function to parse the 2nd argument of format()
2192
$B.parse_format_spec = function(spec){
2195
var pos = 0,
2196
aligns = "<>=^",
2197
digits = "0123456789",
2198
types = "bcdeEfFgGnosxX%",
2200
if(align_pos != -1){
2201
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
2202
// If the second char is also an alignment specifier, the
2203
// first char is the fill value
2204
this.fill = spec.charAt(0)
2205
this.align = spec.charAt(1)
2206
pos = 2
2207
}else{
2208
// The first character defines alignment : fill defaults to ' '
2223
if(car == "+" || car == "-" || car == " "){
2224
this.sign = car
2225
pos++
2226
car = spec.charAt(pos)
2228
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
2229
if(car == "0"){
2238
while(car && digits.indexOf(car) > -1){
2239
if(this.width === undefined){this.width = car}
2240
else{this.width += car}
2241
pos++
2242
car = spec.charAt(pos)
2245
if(this.width === undefined && car == "{"){
2246
// Width is determined by a parameter
2247
var end_param_pos = spec.substr(pos).search("}")
2248
this.width = spec.substring(pos, end_param_pos)
2249
console.log("width", "[" + this.width + "]")
2250
pos += end_param_pos + 1
2251
}
2252
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
2253
if(car == "."){
2254
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
2255
throw _b_.ValueError.$factory(
2256
"Missing precision in format spec")
2258
this.precision = spec.charAt(pos + 1)
2259
pos += 2
2260
car = spec.charAt(pos)
2261
while(car && digits.indexOf(car) > -1){
2268
if(car && types.indexOf(car) > -1){
2269
this.type = car
2270
pos++
2271
car = spec.charAt(pos)
2272
}
2273
if(pos !== spec.length){
2279
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
2280
(this.align || "") +
2281
(this.sign || "") +
2282
(this.alternate ? "#" : "") +
2283
(this.sign_aware ? "0" : "") +
2284
(this.width || "") +
2285
(this.comma ? "," : "") +
2286
(this.precision ? "." + this.precision : "") +
2287
(this.type || "")
2292
if(fmt.width && s.length < fmt.width){
2293
var fill = fmt.fill || " ",
2294
align = fmt.align || "<",
2295
missing = fmt.width - s.length
2297
case "<":
2298
return s + fill.repeat(missing)
2299
case ">":
2300
return fill.repeat(missing) + s
2301
case "=":
2302
if("+-".indexOf(s.charAt(0)) > -1){
2303
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
2307
case "^":
2308
var left = parseInt(missing / 2)
2309
return fill.repeat(left) + s + fill.repeat(missing - left)
2322
$B.parse_fstring = function(string){
2323
// Parse a f-string
2324
var elts = [],
2325
pos = 0,
2349
}else{
2350
throw Error(" f-string: single '}' is not allowed")
2351
}
2352
}else{
2374
current += car
2375
i += 2
2376
}else{
2377
throw Error(" f-string: single '}' is not allowed")
2378
}
2379
}else{
2380
current += car
2381
i++
2382
}
2383
}
2385
}else if(ctype == "debug"){
2386
// after the equal sign, whitespace are ignored and the only
2387
// valid characters are } and :
2388
while(string.charAt(i) == " "){i++}
2389
if(string.charAt(i) == "}"){
2390
// end of debug expression
2391
elts.push(current)
2392
ctype = null
2393
current = ""
2394
pos = i + 1
2395
}
2396
}else{
2397
// End of expression is the } matching the opening {
2398
// There may be nested braces
2399
var i = pos,
2400
nb_braces = 1,
2422
// backslash is not allowed in expressions
2423
throw Error("f-string expression part cannot include a" +
2424
" backslash")
2431
throw Error("f-string: invalid conversion character:" +
2432
" expected 's', 'r', or 'a'")
2433
}else{
2447
if(string.substr(i, 3) == '"""'){
2448
var end = string.indexOf('"""', i + 3)
2449
if(end == -1){
2450
throw Error("f-string: unterminated string")
2451
}else{
2452
var trs = string.substring(i, end + 3)
2453
trs = trs.replace("\n", "\\n\\")
2458
var end = string.indexOf('"', i + 1)
2459
if(end == -1){
2460
throw Error("f-string: unterminated string")
2461
}else{
2462
current.expression += string.substring(i, end + 1)
2463
i = end + 1
2472
var ce = current.expression,
2473
last_char = ce.charAt(ce.length - 1),
2474
last_char_re = ('()'.indexOf(last_char) > -1 ? "\\" : "") + last_char
2479
"=!<>:".search(last_char_re) > -1){
2480
current.expression += car //+ string.charAt(i + 1)
2481
i += 1
2482
}else{
2483
// add debug string
2484
tail = car
2485
while(string.charAt(i + 1).match(/\s/)){
2486
tail += string.charAt(i + 1)
2487
i++
2488
}
2489
elts.push(current.expression + tail)
2490
// remove trailing whitespace from expression
2491
while(ce.match(/\s$/)){
2492
ce = ce.substr(0, ce.length - 1)
2493
}
2494
current.expression = ce
2495
ctype = "debug"
2496
i++
2497
}
2512
// Class for strings with surrogate pairs. We can't rely on Javascript
2513
// strings in this case because they don't count characters like Python
2514
2515
var surrogate = str.$surrogate = $B.make_class("surrogate_string", function(s){
2516
// create an instance of str subclass for strings with surrogate pairs
2517
var items = []
2518
for(var i = 0, len = s.length; i < len; i++){
2519
var code = s.charCodeAt(i)
2520
if(code >= 0xD800 && code <= 0xDBFF){
2521
i++
2522
var low = s.charCodeAt(i)
2523
code = ((code - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000
2524
}
2525
items.push(String.fromCodePoint(code))
2526
}
2527
return {
2528
__class__: str.$surrogate,
2529
items: items
2530
}
2531
})
2532
2533
surrogate.__mro__ = [str, object]
2534
2535
surrogate.__contains__ = function(self, other){
2536
return str.__contains__(self.items.join(''), other)
2537
}
2538
2539
surrogate.__getitem__ = function(self, arg){
2540
if(isinstance(arg, _b_.int)){
2541
var pos = arg
2542
if(arg < 0){
2543
pos += self.items.length
2544
}
2545
if(pos >= 0 && pos < self.items.length){
2546
if(self.items[pos].length == 2){
2547
return surrogate.$factory(self.items[pos])
2548
}
2549
return self.items[pos]
2550
}
2551
throw _b_.IndexError.$factory("string index out of range")
2552
}
2553
if(isinstance(arg, slice)) {
2554
var s = _b_.slice.$conv_for_seq(arg, self.items.length),
2555
start = s.start,
2556
stop = s.stop,
2557
step = s.step
2558
var res = "",
2559
i = null
2560
if(step > 0){
2561
if(stop <= start){return ""}
2562
for(var i = start; i < stop; i += step){
2563
res += self.items[i]
2564
}
2565
}else{
2566
if(stop >= start){return ''}
2567
for(var i = start; i > stop; i += step){
2568
res += self.items[i]
2569
}
2570
}
2571
return res
2572
}
2573
if(isinstance(arg, _b_.bool)){
2574
return surrogate.__getitem__(self, _b_.int.$factory(arg))
2575
}
2576
throw _b_.TypeError.$factory("string indices must be integers")
2577
}
2578
2579
surrogate.__hash__ = function(self){
2580
return str.__hash__(self.items.join(''))
2581
}
2582
2583
surrogate.__iter__ = function(self){
2584
return str_iterator.$factory(self.items)
2585
}
2586
2587
surrogate.__len__ = function(self){
2588
return self.items.length
2589
}
2590
2591
surrogate.__repr__ = function(self){
2592
return str.__repr__(self.items.join(''))
2593
}
2594
2595
surrogate.__str__ = function(self){
2596
return str.__str__(self.items.join(''))
2597
}
2598
2599
$B.set_func_names(surrogate, "builtins")
2600
2601