Permalink
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Dec 20, 2018
Dec 20, 2018
Mar 19, 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
Mar 19, 2018
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
Mar 19, 2018
Mar 19, 2018
Mar 27, 2019
Mar 19, 2018
Mar 19, 2018
Feb 9, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Nov 12, 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
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Dec 10, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 14, 2018
Mar 19, 2018
Mar 19, 2018
Jul 28, 2018
Mar 19, 2019
Nov 2, 2018
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
Jun 29, 2017
Jul 10, 2017
Jul 10, 2017
Mar 19, 2018
Mar 19, 2018
Newer
100644
2099 lines (1927 sloc)
66.6 KB
7
// Polyfill for older browsers
8
// The code does not use a regex to make it a bit faster.
9
// Implementation taken from a comment by Timo on the blog:
10
// http://blog.stevenlevithan.com/archives/faster-trim-javascript
11
String.prototype.trim = function () {
12
var c
13
for(var i = 0; i < this.length; i++){
14
c = this.charCodeAt(i)
15
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
16
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
17
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
18
continue
19
}else{break}
20
}
21
for(var j = this.length - 1; j >= i; j--){
22
c = this.charCodeAt(j)
24
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
25
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
26
continue
27
}else{break}
28
}
29
return this.substring(i, j + 1);
30
}
33
// Convenience method for browsers which do not have a native trimLeft
34
// (which is a nonstandard extension in Firefox and Chrome)
35
String.prototype.trimLeft = function () {
36
var c
37
for(var i = 0; i < this.length; i++){
38
c = this.charCodeAt(i)
40
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
41
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
42
continue
43
}else{break}
44
}
45
return this.substring(i)
49
String.prototype.trimRight = function () {
50
// Convenience method for browsers which do not have a native trimRight
51
// (which is a nonstandard extension in Firefox and Chrome)
52
var c
53
for(var j = this.length - 1; j >= 0; j--){
54
c = this.charCodeAt(j)
55
if([32, 10, 13, 9, 12, 11, 160, 5760, 6158, 8192, 8193, 8194,
56
8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8232,
57
8233, 8239, 8287, 12288, 65279].indexOf(c) > -1){
58
continue
59
}else{break}
60
}
61
return this.substring(0, j + 1)
79
if($.start === null || $.start === _b_.None){$.start = 0}
80
else if($.start < 0){
81
$.start += $.self.length
82
$.start = Math.max(0, $.start)
83
}
84
if($.end === null || $.end === _b_.None){$.end = $.self.length}
85
else if($.end < 0){
86
$.end += $.self.length
87
$.end = Math.max(0, $.end)
88
}
90
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
91
throw _b_.TypeError.$factory("slice indices must be integers " +
92
"or None or have an __index__ method")
93
}
110
if(!(typeof other === "string")){
111
try{return getattr(other, "__radd__")(self)}
112
catch(err){
113
throw _b_.TypeError.$factory("Can't convert " +
119
str.__contains__ = function(self, item){
120
if(!(typeof item == "string")){
121
throw _b_.TypeError.$factory("'in <string>' requires " +
122
"string as left operand, not " + item.__class__)
123
}
125
if(nbcar == 0) {return true} // a string contains the empty string
126
if(self.length == 0){return nbcar == 0}
127
for(var i = 0, len = self.length; i < len; i++){
128
if(self.substr(i, nbcar) == item){return true}
137
// __dir__must be assigned explicitely because attribute resolution for
138
// builtin classes doesn't use __mro__
142
if(other === undefined){ // compare object "self" to class "str"
143
return self === str
153
if(fmt.type && fmt.type != "s"){
154
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
162
if(fmt.sign !== undefined){
163
throw _b_.ValueError.$factory(
164
"Sign not allowed in string format specifier")
174
if(arg < 0) {pos += self.length}
175
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
176
throw _b_.IndexError.$factory("string index out of range")
177
}
178
if(isinstance(arg, slice)) {
179
var s = _b_.slice.$conv_for_seq(arg, self.length),
180
start = s.start,
181
stop = s.stop,
182
step = s.step
183
var res = "",
185
if(step > 0){
186
if(stop <= start){return ""}
187
for(var i = start; i < stop; i += step){res += self.charAt(i)}
189
if(stop >= start){return ''}
190
for(var i = start; i > stop; i += step){res += self.charAt(i)}
198
var prefix = 2,
199
suffix = 3,
200
mask = (2 ** 32 - 1)
201
function fnv(p){
202
if(p.length == 0){
203
return 0
204
}
206
var x = prefix
207
x = (x ^ (p.charCodeAt(0) << 7)) & mask
208
for(var i = 0, len = p.length; i < len; i++){
209
x = ((1000003 * x) ^ p.charCodeAt(i)) & mask
210
}
211
x = (x ^ p.length) & mask
212
x = (x ^ suffix) & mask
232
var items = self.split("") // list of all characters in string
233
return $B.$iterator(items, $str_iterator)
270
// left adjusted
271
return s + get_char_array(padding - s.length, flags.pad_char)
272
}
273
}
274
282
if(val.__class__ === $B.long_int){
283
s = $B.long_int.to_base(val, 10)
284
}else{
285
s = val.toString()
287
if(s[0] === "-"){
288
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
299
if(val === Infinity){
300
val = "inf"
301
}else if(val === -Infinity){
302
val = "-inf"
303
}else{
304
val = "nan"
326
var str_format = function(val, flags) {
327
// string format supports left and right padding
328
flags.pad_char = " " // even if 0 padding is defined, don't use it
334
if(val.__class__ === $B.long_int){
335
val = $B.long_int.to_base(val, 10)
336
}else{
337
val = parseInt(val)
355
var repr_format = function(val, flags) {
356
flags.pad_char = " " // even if 0 padding is defined, don't use it
357
return format_padding(repr(val), flags)
358
}
360
var ascii_format = function(val, flags) {
361
flags.pad_char = " " // even if 0 padding is defined, don't use it
362
return format_padding(ascii(val), flags)
363
}
375
flags.precision = parseInt(flags.precision, 10)
376
validate_precision(flags.precision)
377
}
378
return parseFloat(val)
379
}
382
var trailing_zeros = /(.*?)(0+)([eE].*)/,
383
leading_zeros = /\.(0*)/,
384
trailing_dot = /\.$/
386
var validate_precision = function(precision) {
387
// force precision to limits of javascript
392
var floating_point_format = function(val, upper, flags){
393
val = _float_helper(val, flags),
394
v = val.toString(),
395
v_len = v.length,
396
dot_idx = v.indexOf('.')
397
if(dot_idx < 0){dot_idx = v_len}
398
if(val < 1 && val > -1){
399
var zeros = leading_zeros.exec(v),
400
numzeros
401
if(zeros){
406
if(numzeros >= 4){
407
val = format_sign(val, flags) + format_float_precision(val, upper,
408
flags, _floating_g_exp_helper)
409
if(!flags.alternate){
422
return format_padding(format_sign(val, flags) +
423
format_float_precision(val, upper, flags,
424
function(val, precision) {
425
return val.toFixed(min(precision, v_len - dot_idx) +
426
numzeros)
427
}),
428
flags
429
)
430
}
431
432
if(dot_idx > flags.precision){
433
val = format_sign(val, flags) + format_float_precision(val, upper,
434
flags, _floating_g_exp_helper)
435
if(! flags.alternate){
447
return format_padding(format_sign(val, flags) +
448
format_float_precision(val, upper, flags,
449
function(val, precision) {
450
if(!flags.decimal_point){
451
precision = min(v_len - 1, 6)
452
}else if (precision > v_len){
453
if(! flags.alternate){
454
precision = v_len
455
}
457
if(precision < dot_idx){
458
precision = dot_idx
459
}
460
return val.toFixed(precision - dot_idx)
461
}),
462
flags
463
)
466
var _floating_g_exp_helper = function(val, precision, flags, upper){
467
if(precision){--precision}
470
var e_idx = val.lastIndexOf("e")
471
if(e_idx > val.length - 4){
472
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
475
return val
476
}
477
478
// fF
479
var floating_point_decimal_format = function(val, upper, flags) {
480
val = _float_helper(val, flags)
481
return format_padding(format_sign(val, flags) +
482
format_float_precision(val, upper, flags,
483
function(val, precision, flags) {
484
val = val.toFixed(precision)
485
if(precision === 0 && flags.alternate){
486
val += '.'
487
}
488
return val
489
}),
490
flags
491
)
492
}
493
494
var _floating_exp_helper = function(val, precision, flags, upper) {
495
val = val.toExponential(precision)
496
// pad exponent to two digits
509
return format_padding(format_sign(val, flags) +
510
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
536
if(flags.alternate){
537
if(ret.charAt(0) === "-"){
538
if(upper){ret = "-0X" + ret.slice(1)}
539
else{ret = "-0x" + ret.slice(1)}
540
}else{
541
if(upper){ret = "0X" + ret}
542
else{ret = "0x" + ret}
552
if(val.__class__ === $B.long_int){
553
ret = $B.long_int.to_base(8)
554
}else{
555
ret = parseInt(val)
556
ret = ret.toString(8)
572
if(flags.alternate){
573
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
574
else{ret = "0o" + ret}
579
var single_char_format = function(val, flags){
580
if(isinstance(val, str) && val.length == 1) return val
581
try{
589
var num_flag = function(c, flags){
590
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
591
flags.pad_char = "0"
597
flags.precision = (flags.precision || "") + c
598
}
599
}
600
601
var decimal_point_flag = function(val, flags) {
603
// can only have one decimal point
604
throw new UnsupportedChar()
605
}
606
flags.decimal_point = true
607
}
608
609
var neg_flag = function(val, flags){
610
flags.pad_char = " " // overrides '0' flag
627
"s": str_format,
628
"d": num_format,
629
"i": num_format,
630
"u": num_format,
631
"o": octal_format,
632
"r": repr_format,
633
"a": ascii_format,
634
"g": function(val, flags){
635
return floating_point_format(val, false, flags)
636
},
637
"G": function(val, flags){return floating_point_format(val, true, flags)},
638
"f": function(val, flags){
639
return floating_point_decimal_format(val, false, flags)
640
},
641
"F": function(val, flags){
642
return floating_point_decimal_format(val, true, flags)
643
},
644
"e": function(val, flags){
645
return floating_point_exponential_format(val, false, flags)
646
},
647
"E": function(val, flags){
648
return floating_point_exponential_format(val, true, flags)
649
},
650
"x": function(val, flags){return signed_hex_format(val, false, flags)},
651
"X": function(val, flags){return signed_hex_format(val, true, flags)},
652
"c": single_char_format,
653
"0": function(val, flags){return num_flag("0", flags)},
654
"1": function(val, flags){return num_flag("1", flags)},
655
"2": function(val, flags){return num_flag("2", flags)},
656
"3": function(val, flags){return num_flag("3", flags)},
657
"4": function(val, flags){return num_flag("4", flags)},
658
"5": function(val, flags){return num_flag("5", flags)},
659
"6": function(val, flags){return num_flag("6", flags)},
660
"7": function(val, flags){return num_flag("7", flags)},
661
"8": function(val, flags){return num_flag("8", flags)},
662
"9": function(val, flags){return num_flag("9", flags)},
663
"-": neg_flag,
664
" ": space_flag,
665
"+": sign_flag,
666
".": decimal_point_flag,
667
"#": alternate_flag
668
}
669
670
// exception thrown when an unsupported char is encountered in legacy format
717
if(self === undefined){
718
throw _b_.TypeError.$factory(
719
"not enough arguments for format string")
746
throw _b_.ValueError.$factory(
747
"unsupported format character '" + invalid_char +
748
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
749
") at index " + newpos)
750
}else if(err.name === "NotANumber"){
751
var try_char = s[newpos],
752
cls = self.__class__
753
if(!cls){
754
if(typeof(self) === "string"){
755
cls = "str"
756
}else{
762
throw _b_.TypeError.$factory("%" + try_char +
763
" format: a number is required, not " + cls)
764
}else{
796
}while(pos < length)
797
798
if(argpos !== null){
799
if(args.length > argpos){
800
throw _b_.TypeError.$factory(
801
"not enough arguments for format string")
802
}else if(args.length < argpos){
803
throw _b_.TypeError.$factory(
804
"not all arguments converted during string formatting")
806
}else if(nbph == 0){
807
throw _b_.TypeError.$factory(
808
"not all arguments converted during string formatting")
816
var $ = $B.args("__mul__", 2, {self: null, other: null},
817
["self", "other"], arguments, {}, null, null)
818
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
819
"Can't multiply sequence by non-int of type '" +
831
res = self.replace(/\\/g, "\\\\")
832
// special cases
833
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
834
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")
841
if(res.search('"') == -1 && res.search("'") == -1){
842
return "'" + res + "'"
843
}else if(self.search('"') == -1){
844
return '"' + res + '"'
845
}
846
var qesc = new RegExp("'", "g") // to escape single quote
847
res = "'" + res.replace(qesc, "\\'") + "'"
851
str.__setitem__ = function(self, attr, value){
852
throw _b_.TypeError.$factory(
853
"'str' object does not support item assignment")
855
var combining = []
856
for(var cp = 0x300; cp <= 0x36F; cp++){
857
combining.push(String.fromCharCode(cp))
858
}
859
var combining_re = new RegExp("(" + combining.join("|") + ")")
871
$comp_func += "" // source code
872
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
881
var $notimplemented = function(self, other){
882
throw NotImplementedError.$factory(
883
"OPERATOR not implemented for class str")
886
// Copy static methods from unicode
887
var from_unicode = [
888
"title",
889
"capitalize",
890
"casefold",
891
"islower",
892
"isupper",
893
"istitle",
894
"isspace",
895
"isalpha",
896
"isalnum",
897
"isdecimal",
898
"isdigit",
899
"isnumeric",
900
"isidentifier",
901
"isprintable",
902
"lower",
903
"swapcase",
904
"upper"
905
]
911
str.center = function(){
912
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
913
["self", "width", "fillchar"],
914
arguments, {fillchar:" "}, null, null),
915
self = $.self
927
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
928
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
936
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
937
else{_slice = _b_.slice.$factory($.start, $.self.length)}
942
if($.sub.length == 0){
943
if($.start == $.self.length){return 1}
944
else if(substr.length == 0){return 0}
945
return substr.length + 1
947
var n = 0,
948
pos = 0
949
while(pos < substr.length){
950
pos = substr.indexOf($.sub, pos)
951
if(pos >= 0){n++; pos += $.sub.length}
952
else{break}
964
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
965
res += String.fromCharCode(String.charCodeAt(char) + 13)
966
}else if(("m" < char && char <= "z") ||
967
("M" < char && char <= "Z")){
968
res += String.fromCharCode(String.charCodeAt(char) - 13)
977
// Return True if the string ends with the specified suffix, otherwise
978
// return False. suffix can also be a tuple of suffixes to look for.
979
// With optional start, test beginning at that position. With optional
983
["self", "suffix", "start", "end"],
984
arguments, {start: 0, end: null}, null, null)
991
var s = $.self.substring($.start, $.end)
992
for(var i = 0, len = suffixes.length; i < len; i++){
996
if(suffix.length <= s.length &&
997
s.substr(s.length - suffix.length) == suffix){return true}
1003
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
1004
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
1005
var s = $B.$GetInt($.tabsize),
1006
col = 0,
1007
pos = 0,
1008
res = ""
1009
if(s == 1){return self.replace(/\t/g," ")}
1010
while(pos < self.length){
1018
res += car
1019
col = 0
1020
break
1021
default:
1022
res += car
1023
col++
1024
break
1025
}
1026
pos++
1027
}
1033
// Return the lowest index in the string where substring sub is found,
1034
// such that sub is contained in the slice s[start:end]. Optional
1035
// arguments start and end are interpreted as in slice notation.
1038
{self: null, sub: null, start: null, end: null},
1039
["self", "sub", "start", "end"],
1040
arguments, {start: 0, end: null}, null, null)
1044
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1045
throw _b_.TypeError.$factory("slice indices must be " +
1046
"integers or None or have an __index__ method")}
1047
var s = $.self.substring($.start, $.end)
1049
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1050
if(s.length + $.sub.length == 0){return -1}
1052
var last_search = s.length - $.sub.length
1053
for(var i = 0; i <= last_search; i++){
1054
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1065
// a.x[z]!r:...
1066
// the object has attributes :
1067
// - name : "a"
1068
// - name_ext : [".x", "[z]"]
1069
// - conv : r
1070
// - spec : rest of string after :
1078
// No : in the string : it only contains a name
1079
name = fmt_string
1080
}else{
1081
// name is before the first ":"
1082
// spec (the format specification) is after
1083
name = elts[0]
1087
var elts = name.split("!")
1088
if(elts.length > 1){
1089
name = elts[0]
1090
conv = elts[1] // conversion flag
1094
// "name' may be a subscription or attribute
1095
// Put these "extensions" in the list "name_ext"
1096
function name_repl(match){
1097
name_ext.push(match)
1099
}
1100
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1101
name = name.replace(name_ext_re, name_repl)
1102
}
1109
// Parse self to detect formatting instructions
1110
// Create a list "parts" made of sections of the string :
1111
// - elements of even rank are literal text
1112
// - elements of odd rank are "format objects", built from the
1113
// format strings in self (of the form {...})
1124
text += "{"
1125
pos += 2
1126
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1133
// Store current literal text
1134
parts.push(text)
1135
1136
// Search the end of the format string, ie the } closing the
1137
// opening {. Since the string can contain other pairs {} for
1138
// nested formatting, an integer nb is incremented for each { and
1139
// decremented for each } ; the end of the format string is
1140
// reached when nb == 0
1141
var end = pos + 1,
1142
nb = 1
1143
while(end < _len){
1144
if(self.charAt(end) == "{"){nb++; end++}
1145
else if(self.charAt(end) == "}"){
1146
nb--; end++
1147
if(nb == 0){
1152
var fmt_obj = $B.parse_format(fmt_string)
1153
fmt_obj.raw_name = fmt_obj.name
1154
fmt_obj.raw_spec = fmt_obj.spec
1189
return parts
1190
}
1191
1192
str.format = function(self) {
1193
var $ = $B.args("format", 1, {self: null}, ["self"],
1194
arguments, {}, "$args", "$kw")
1195
1196
var parts = $B.split_format($.self)
1197
1208
1209
if(fmt.spec !== undefined){
1210
// "spec" may contain "nested replacement fields"
1211
// In this case, evaluate them using the positional
1212
// or keyword arguments passed to format()
1213
function replace_nested(name, key){
1214
if(/\d+/.exec(key)){
1215
// If key is numeric, search in positional
1216
// arguments
1217
return _b_.tuple.__getitem__($.$args,
1218
parseInt(key))
1219
}else{
1220
// Else try in keyword arguments
1221
return _b_.dict.__getitem__($.$kw, key)
1222
}
1223
}
1224
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1225
replace_nested)
1226
}
1228
// Numerical reference : use positional arguments
1229
var pos = parseInt(fmt.name),
1239
// Attribute
1240
value = _b_.getattr(value, ext.substr(1))
1241
}else{
1242
// Subscription
1245
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1246
value = _b_.getattr(value, "__getitem__")(key)
1250
// If the conversion flag is set, first call a function to convert
1251
// the value
1252
if(fmt.conv == "a"){value = _b_.ascii(value)}
1253
else if(fmt.conv == "r"){value = _b_.repr(value)}
1254
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1268
throw NotImplementedError.$factory(
1269
"function format_map not implemented yet")
1289
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1290
"sequence item " + count + ": expected str instance, " +
1304
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1305
["self", "width", "fillchar"],
1306
arguments, {fillchar: " "}, null, null)
1313
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1314
arguments, {chars:_b_.None}, null, null)
1315
if($.chars === _b_.None){return $.self.trimLeft()}
1316
for(var i = 0; i < $.self.length; i++){
1317
if($.chars.indexOf($.self.charAt(i)) === -1){
1318
return $.self.substring(i)
1326
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1327
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1332
// If there is only one argument, it must be a dictionary mapping
1333
// Unicode ordinals (integers) or characters (strings of length 1) to
1334
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1336
if(! _b_.isinstance($.x, _b_.dict)){
1337
throw _b_.TypeError.$factory(
1338
"maketrans only argument must be a dict")
1341
for(var i = 0, len = items.length; i < len; i++){
1342
var k = items[i][0],
1343
v = items[i][1]
1344
if(! _b_.isinstance(k, _b_.int)){
1345
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1346
k = _b_.ord(k)
1347
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1350
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1351
throw _b_.TypeError.$factory("dictionary value " + v +
1359
// and in the resulting dictionary, each character in x will be mapped
1360
// to the character at the same position in y
1363
}else if($.x.length !== $.y.length){
1364
throw _b_.TypeError.$factory(
1365
"maketrans arguments must be strings or same length")
1371
if(! _b_.isinstance($.z, _b_.str)){
1372
throw _b_.TypeError.$factory(
1373
"maketrans third argument must be a string")
1380
var key = _b_.ord($.x.charAt(i)),
1381
value = $.y.charAt(i)
1382
_b_.dict.$setitem(_t, key, value)
1393
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1394
arguments, {}, null, null)
1399
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1400
$.self.substring(i + $.sep.length)])
1401
}
1402
1403
function $re_escape(str){
1404
var specials = "[.*+?|()$^"
1405
for(var i = 0, len = specials.length; i < len; i++){
1406
var re = new RegExp("\\"+specials.charAt(i), "g")
1407
str = str.replace(re, "\\"+specials.charAt(i))
1408
}
1409
return str
1416
var $ = $B.args("replace", 4,
1417
{self: null, old: null, $$new: null, count: null},
1418
["self", "old", "$$new", "count"],
1419
arguments, {count: -1}, null, null),
1420
count = $.count,
1421
self = $.self,
1422
old = $.old,
1423
_new = $.$$new
1430
"' object cannot be interpreted as an integer")
1431
}else if(isinstance(count, _b_.float)){
1432
throw _b_.TypeError.$factory("integer argument expected, got float")
1433
}
1434
if(count == 0){return self}
1435
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1436
if(old == ""){
1437
if(_new == ""){return self}
1438
if(self == ""){return _new}
1439
var elts = self.split("")
1440
if(count > -1 && elts.length >= count){
1441
var rest = elts.slice(count).join("")
1442
return _new + elts.slice(0, count).join(_new) + rest
1443
}else{return _new + elts.join(_new) + _new}
1458
if(count < 0){count = res.length}
1459
while(count > 0){
1460
pos = res.indexOf(old, pos)
1461
if(pos < 0){break}
1462
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1463
pos = pos + _new.length
1464
count--
1470
// Return the highest index in the string where substring sub is found,
1471
// such that sub is contained within s[start:end]. Optional arguments
1474
{self: null, sub: null, start: null, end: null},
1475
["self", "sub", "start", "end"],
1476
arguments, {start: 0, end: null}, null, null)
1488
for(var i = $.end - sublen; i >= $.start; i--){
1489
if($.self.substr(i, sublen) == $.sub){return i}
1496
var res = str.rfind.apply(null, arguments)
1497
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1502
var $ = $B.args("rjust",3,
1503
{self: null, width: null, fillchar: null},
1504
["self", "width", "fillchar"],
1505
arguments, {fillchar: " "}, null, null)
1513
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1514
arguments, {}, null, null)
1518
var items = str.partition(self, sep).reverse()
1519
for(var i = 0; i < items.length; i++){
1520
items[i] = items[i].split("").reverse().join("")
1526
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1527
["self", "sep", "maxsplit"], arguments,
1528
{sep: _b_.None, maxsplit: -1}, null, null),
1529
sep = $.sep
1532
var rev_str = reverse($.self),
1533
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1544
str.rstrip = function(self, x){
1545
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1546
arguments, {chars: _b_.None}, null, null)
1547
if($.chars === _b_.None){return $.self.trimRight()}
1549
if($.chars.indexOf($.self.charAt(j)) == -1){
1550
return $.self.substring(0, j + 1)
1557
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1558
["self", "sep", "maxsplit"], arguments,
1559
{sep: _b_.None, maxsplit: -1}, null, null),
1560
sep = $.sep,
1561
maxsplit = $.maxsplit,
1562
self = $.self,
1563
pos = 0
1564
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1565
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1566
if(sep === _b_.None){
1568
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1569
if(pos === self.length - 1){return [self]}
1570
var name = ""
1572
if(self.charAt(pos).search(/\s/) == -1){
1573
if(name == ""){name = self.charAt(pos)}
1574
else{name += self.charAt(pos)}
1594
var res = [],
1595
s = "",
1596
seplen = sep.length
1597
if(maxsplit == 0){return [self]}
1598
while(pos < self.length){
1599
if(self.substr(pos, seplen) == sep){
1619
["self", "keepends"], arguments, {keepends: false}, null, null)
1620
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1621
throw _b_.TypeError.$factory("integer argument expected, got " +
1628
start = pos,
1629
pos = 0,
1630
self = $.self
1631
while(pos < self.length){
1632
if(self.substr(pos, 2) == "\r\n"){
1633
res.push(self.substring(start, pos + 2))
1634
start = pos + 2
1636
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1637
res.push(self.substring(start, pos + 1))
1638
start = pos + 1
1639
pos = start
1640
}else{pos++}
1641
}
1642
var rest = self.substr(start)
1643
if(rest){res.push(rest)}
1644
return res
1645
}else{
1652
// Return True if string starts with the prefix, otherwise return False.
1653
// prefix can also be a tuple of prefixes to look for. With optional
1654
// start, test string beginning at that position. With optional end,
1656
var $ = $B.args("startswith", 4,
1657
{self: null, prefix: null, start: null, end: null},
1658
["self", "prefix", "start", "end"],
1659
arguments, {start: 0, end: null}, null, null)
1666
var s = $.self.substring($.start, $.end)
1667
for(var i = 0, len = prefixes.length; i < len; i++){
1678
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1679
arguments, {chars: _b_.None}, null, null)
1680
if($.chars === _b_.None){return $.self.trim()}
1681
for(var i = 0; i < $.self.length; i++){
1682
if($.chars.indexOf($.self.charAt(i)) == -1){
1683
break
1686
for(var j = $.self.length - 1; j >= i; j--){
1687
if($.chars.indexOf($.self.charAt(j)) == -1){
1688
break
1696
getitem = $B.$getattr(table, "__getitem__")
1697
for(var i = 0, len = self.length; i < len; i++){
1698
try{
1699
var repl = getitem(self.charCodeAt(i))
1700
if(repl !== _b_.None){
1701
res.push(repl)
1702
}
1703
}catch(err){
1704
res.push(self.charAt(i))
1705
}
1712
["self", "width"], arguments, {}, null, null)
1713
if($.width <= self.length){return self}
1715
case "+":
1716
case "-":
1717
return self.charAt(0) +
1718
"0".repeat($.width - self.length) + self.substr(1)
1736
// class or its subclasses, but the attribute __str__ of the
1737
// class metaclass (usually "type") or its subclasses (usually
1738
// "object")
1739
// The metaclass is the attribute __class__ of the class dictionary
1743
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1744
encoding !== undefined){
1745
// str(bytes, encoding, errors) is equal to
1746
// bytes.decode(encoding, errors)
1747
// Arguments may be passed as keywords (cf. issue #1060)
1748
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
1749
["arg", "encoding", "errors"], arguments,
1750
{encoding: "utf-8", errors: "strict"}, null, null)
1751
return _b_.bytes.decode(arg, $.encoding, $.errors)
1753
var f = $B.$getattr(arg, "__str__", null)
1754
if(f === null ||
1755
// if not better than object.__str__, try __repr__
1756
(arg.__class__ && arg.__class__ !== _b_.object &&
1757
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1758
var f = $B.$getattr(arg, "__repr__")
1759
}
1764
if($B.debug > 1){console.log(err)}
1765
console.log("Warning - no method __str__ or __repr__, " +
1766
"default to toString", arg)
1767
return arg.toString()
1773
if(cls === undefined){
1774
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1798
var args = [],
1799
pos = 0
1800
if(arguments.length > 0){
1801
var args = [arguments[0].valueOf()],
1802
pos = 1
1803
for(var i = 1, len = arguments.length; i < len; i++){
1804
args[pos++] = arguments[i]
1820
// Function to parse the 2nd argument of format()
1821
$B.parse_format_spec = function(spec){
1824
var pos = 0,
1825
aligns = "<>=^",
1826
digits = "0123456789",
1827
types = "bcdeEfFgGnosxX%",
1829
if(align_pos != -1){
1830
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1831
// If the second char is also an alignment specifier, the
1832
// first char is the fill value
1833
this.fill = spec.charAt(0)
1834
this.align = spec.charAt(1)
1835
pos = 2
1836
}else{
1837
// The first character defines alignment : fill defaults to ' '
1852
if(car == "+" || car == "-" || car == " "){
1853
this.sign = car
1854
pos++
1855
car = spec.charAt(pos)
1857
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1858
if(car == "0"){
1865
while(car && digits.indexOf(car) > -1){
1866
if(this.width === undefined){this.width = car}
1867
else{this.width += car}
1868
pos++
1869
car = spec.charAt(pos)
1872
if(this.width === undefined && car == "{"){
1873
// Width is determined by a parameter
1874
var end_param_pos = spec.substr(pos).search("}")
1875
this.width = spec.substring(pos, end_param_pos)
1876
console.log("width", "[" + this.width + "]")
1877
pos += end_param_pos + 1
1878
}
1879
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1880
if(car == "."){
1881
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1882
throw _b_.ValueError.$factory(
1883
"Missing precision in format spec")
1885
this.precision = spec.charAt(pos + 1)
1886
pos += 2
1887
car = spec.charAt(pos)
1888
while(car && digits.indexOf(car) > -1){
1895
if(car && types.indexOf(car) > -1){
1896
this.type = car
1897
pos++
1898
car = spec.charAt(pos)
1899
}
1900
if(pos !== spec.length){
1905
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1906
(this.align || "") +
1907
(this.sign || "") +
1908
(this.alternate ? "#" : "") +
1909
(this.sign_aware ? "0" : "") +
1910
(this.width || "") +
1911
(this.comma ? "," : "") +
1912
(this.precision ? "." + this.precision : "") +
1913
(this.type || "")
1918
if(fmt.width && s.length < fmt.width){
1919
var fill = fmt.fill || " ",
1920
align = fmt.align || "<",
1921
missing = fmt.width - s.length
1923
case "<":
1924
return s + fill.repeat(missing)
1925
case ">":
1926
return fill.repeat(missing) + s
1927
case "=":
1928
if("+-".indexOf(s.charAt(0)) > -1){
1929
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1933
case "^":
1934
var left = parseInt(missing / 2)
1935
return fill.repeat(left) + s + fill.repeat(missing - left)
1948
$B.parse_fstring = function(string){
1949
// Parse a f-string
1950
var elts = [],
1951
pos = 0,
1975
}else{
1976
throw Error(" f-string: single '}' is not allowed")
1977
}
1978
}else{
2000
current += car
2001
i += 2
2002
}else{
2003
throw Error(" f-string: single '}' is not allowed")
2004
}
2005
}else{
2006
current += car
2007
i++
2008
}
2009
}
2011
}else{
2012
// End of expression is the } matching the opening {
2013
// There may be nested braces
2014
var i = pos,
2015
nb_braces = 1,
2037
// backslash is not allowed in expressions
2038
throw Error("f-string expression part cannot include a" +
2039
" backslash")
2046
throw Error("f-string: invalid conversion character:" +
2047
" expected 's', 'r', or 'a'")
2048
}else{
2062
if(string.substr(i, 3) == '"""'){
2063
var end = string.indexOf('"""', i + 3)
2064
if(end == -1){
2065
throw Error("f-string: unterminated string")
2066
}else{
2067
var trs = string.substring(i, end + 3)
2068
trs = trs.replace("\n", "\\n\\")
2073
var end = string.indexOf('"', i + 1)
2074
if(end == -1){
2075
throw Error("f-string: unterminated string")
2076
}else{
2077
current.expression += string.substring(i, end + 1)
2078
i = end + 1