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
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
Apr 2, 2019
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
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
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
2116 lines (1941 sloc)
67.2 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
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}
957
str.encode = function(){
958
var $ = $B.args("encode", 3, {self: null, encoding: null, errors: null},
959
["self", "encoding", "errors"], arguments,
960
{encoding: "utf-8", errors: "strict"}, null, null)
961
if($.encoding == "rot13" || $.encoding == "rot_13"){
966
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
967
res += String.fromCharCode(String.charCodeAt(char) + 13)
968
}else if(("m" < char && char <= "z") ||
969
("M" < char && char <= "Z")){
970
res += String.fromCharCode(String.charCodeAt(char) - 13)
979
// Return True if the string ends with the specified suffix, otherwise
980
// return False. suffix can also be a tuple of suffixes to look for.
981
// With optional start, test beginning at that position. With optional
985
["self", "suffix", "start", "end"],
986
arguments, {start: 0, end: null}, null, null)
993
var s = $.self.substring($.start, $.end)
994
for(var i = 0, len = suffixes.length; i < len; i++){
998
if(suffix.length <= s.length &&
999
s.substr(s.length - suffix.length) == suffix){return true}
1005
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
1006
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
1007
var s = $B.$GetInt($.tabsize),
1008
col = 0,
1009
pos = 0,
1010
res = ""
1011
if(s == 1){return self.replace(/\t/g," ")}
1012
while(pos < self.length){
1020
res += car
1021
col = 0
1022
break
1023
default:
1024
res += car
1025
col++
1026
break
1027
}
1028
pos++
1029
}
1035
// Return the lowest index in the string where substring sub is found,
1036
// such that sub is contained in the slice s[start:end]. Optional
1037
// arguments start and end are interpreted as in slice notation.
1040
{self: null, sub: null, start: null, end: null},
1041
["self", "sub", "start", "end"],
1042
arguments, {start: 0, end: null}, null, null)
1046
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1047
throw _b_.TypeError.$factory("slice indices must be " +
1048
"integers or None or have an __index__ method")}
1049
var s = $.self.substring($.start, $.end)
1051
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1052
if(s.length + $.sub.length == 0){return -1}
1054
var last_search = s.length - $.sub.length
1055
for(var i = 0; i <= last_search; i++){
1056
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1067
// a.x[z]!r:...
1068
// the object has attributes :
1069
// - name : "a"
1070
// - name_ext : [".x", "[z]"]
1071
// - conv : r
1072
// - spec : rest of string after :
1080
// No : in the string : it only contains a name
1081
name = fmt_string
1082
}else{
1083
// name is before the first ":"
1084
// spec (the format specification) is after
1085
name = elts[0]
1089
var elts = name.split("!")
1090
if(elts.length > 1){
1091
name = elts[0]
1092
conv = elts[1] // conversion flag
1096
// "name' may be a subscription or attribute
1097
// Put these "extensions" in the list "name_ext"
1098
function name_repl(match){
1099
name_ext.push(match)
1101
}
1102
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1103
name = name.replace(name_ext_re, name_repl)
1104
}
1111
// Parse self to detect formatting instructions
1112
// Create a list "parts" made of sections of the string :
1113
// - elements of even rank are literal text
1114
// - elements of odd rank are "format objects", built from the
1115
// format strings in self (of the form {...})
1126
text += "{"
1127
pos += 2
1128
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1135
// Store current literal text
1136
parts.push(text)
1137
1138
// Search the end of the format string, ie the } closing the
1139
// opening {. Since the string can contain other pairs {} for
1140
// nested formatting, an integer nb is incremented for each { and
1141
// decremented for each } ; the end of the format string is
1142
// reached when nb == 0
1143
var end = pos + 1,
1144
nb = 1
1145
while(end < _len){
1146
if(self.charAt(end) == "{"){nb++; end++}
1147
else if(self.charAt(end) == "}"){
1148
nb--; end++
1149
if(nb == 0){
1154
var fmt_obj = $B.parse_format(fmt_string)
1155
fmt_obj.raw_name = fmt_obj.name
1156
fmt_obj.raw_spec = fmt_obj.spec
1191
return parts
1192
}
1193
1194
str.format = function(self) {
1195
var $ = $B.args("format", 1, {self: null}, ["self"],
1196
arguments, {}, "$args", "$kw")
1197
1198
var parts = $B.split_format($.self)
1199
1210
1211
if(fmt.spec !== undefined){
1212
// "spec" may contain "nested replacement fields"
1213
// In this case, evaluate them using the positional
1214
// or keyword arguments passed to format()
1215
function replace_nested(name, key){
1216
if(/\d+/.exec(key)){
1217
// If key is numeric, search in positional
1218
// arguments
1219
return _b_.tuple.__getitem__($.$args,
1220
parseInt(key))
1221
}else{
1222
// Else try in keyword arguments
1223
return _b_.dict.__getitem__($.$kw, key)
1224
}
1225
}
1226
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1227
replace_nested)
1228
}
1230
// Numerical reference : use positional arguments
1231
var pos = parseInt(fmt.name),
1241
// Attribute
1242
value = _b_.getattr(value, ext.substr(1))
1243
}else{
1244
// Subscription
1247
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1248
value = _b_.getattr(value, "__getitem__")(key)
1252
// If the conversion flag is set, first call a function to convert
1253
// the value
1254
if(fmt.conv == "a"){value = _b_.ascii(value)}
1255
else if(fmt.conv == "r"){value = _b_.repr(value)}
1256
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1270
throw NotImplementedError.$factory(
1271
"function format_map not implemented yet")
1281
str.isascii = function(self){
1282
// Return true if the string is empty or all characters in the string are
1283
// ASCII, false otherwise. ASCII characters have code points in the range
1284
// U+0000-U+007F.
1285
for(var i = 0, len = self.length; i < len; i++){
1286
if(self.charCodeAt(i) > 127){return false}
1287
}
1288
return true
1289
}
1290
1301
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1302
"sequence item " + count + ": expected str instance, " +
1316
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1317
["self", "width", "fillchar"],
1318
arguments, {fillchar: " "}, null, null)
1325
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1326
arguments, {chars:_b_.None}, null, null)
1327
if($.chars === _b_.None){return $.self.trimLeft()}
1328
for(var i = 0; i < $.self.length; i++){
1329
if($.chars.indexOf($.self.charAt(i)) === -1){
1330
return $.self.substring(i)
1338
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1339
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1344
// If there is only one argument, it must be a dictionary mapping
1345
// Unicode ordinals (integers) or characters (strings of length 1) to
1346
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1348
if(! _b_.isinstance($.x, _b_.dict)){
1349
throw _b_.TypeError.$factory(
1350
"maketrans only argument must be a dict")
1353
for(var i = 0, len = items.length; i < len; i++){
1354
var k = items[i][0],
1355
v = items[i][1]
1356
if(! _b_.isinstance(k, _b_.int)){
1357
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1358
k = _b_.ord(k)
1359
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1362
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1363
throw _b_.TypeError.$factory("dictionary value " + v +
1371
// and in the resulting dictionary, each character in x will be mapped
1372
// to the character at the same position in y
1375
}else if($.x.length !== $.y.length){
1376
throw _b_.TypeError.$factory(
1377
"maketrans arguments must be strings or same length")
1383
if(! _b_.isinstance($.z, _b_.str)){
1384
throw _b_.TypeError.$factory(
1385
"maketrans third argument must be a string")
1407
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1408
arguments, {}, null, null)
1413
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1414
$.self.substring(i + $.sep.length)])
1415
}
1416
1417
function $re_escape(str){
1418
var specials = "[.*+?|()$^"
1419
for(var i = 0, len = specials.length; i < len; i++){
1420
var re = new RegExp("\\"+specials.charAt(i), "g")
1421
str = str.replace(re, "\\"+specials.charAt(i))
1422
}
1423
return str
1430
var $ = $B.args("replace", 4,
1431
{self: null, old: null, $$new: null, count: null},
1432
["self", "old", "$$new", "count"],
1433
arguments, {count: -1}, null, null),
1434
count = $.count,
1435
self = $.self,
1436
old = $.old,
1437
_new = $.$$new
1444
"' object cannot be interpreted as an integer")
1445
}else if(isinstance(count, _b_.float)){
1446
throw _b_.TypeError.$factory("integer argument expected, got float")
1447
}
1448
if(count == 0){return self}
1449
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1450
if(old == ""){
1451
if(_new == ""){return self}
1452
if(self == ""){return _new}
1453
var elts = self.split("")
1454
if(count > -1 && elts.length >= count){
1455
var rest = elts.slice(count).join("")
1456
return _new + elts.slice(0, count).join(_new) + rest
1457
}else{return _new + elts.join(_new) + _new}
1472
if(count < 0){count = res.length}
1473
while(count > 0){
1474
pos = res.indexOf(old, pos)
1475
if(pos < 0){break}
1476
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1477
pos = pos + _new.length
1478
count--
1484
// Return the highest index in the string where substring sub is found,
1485
// such that sub is contained within s[start:end]. Optional arguments
1488
{self: null, sub: null, start: null, end: null},
1489
["self", "sub", "start", "end"],
1490
arguments, {start: 0, end: null}, null, null)
1502
for(var i = $.end - sublen; i >= $.start; i--){
1503
if($.self.substr(i, sublen) == $.sub){return i}
1510
var res = str.rfind.apply(null, arguments)
1511
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1516
var $ = $B.args("rjust",3,
1517
{self: null, width: null, fillchar: null},
1518
["self", "width", "fillchar"],
1519
arguments, {fillchar: " "}, null, null)
1527
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1528
arguments, {}, null, null)
1532
var items = str.partition(self, sep).reverse()
1533
for(var i = 0; i < items.length; i++){
1534
items[i] = items[i].split("").reverse().join("")
1540
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1541
["self", "sep", "maxsplit"], arguments,
1542
{sep: _b_.None, maxsplit: -1}, null, null),
1543
sep = $.sep
1546
var rev_str = reverse($.self),
1547
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1558
str.rstrip = function(self, x){
1559
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1560
arguments, {chars: _b_.None}, null, null)
1561
if($.chars === _b_.None){return $.self.trimRight()}
1563
if($.chars.indexOf($.self.charAt(j)) == -1){
1564
return $.self.substring(0, j + 1)
1571
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1572
["self", "sep", "maxsplit"], arguments,
1573
{sep: _b_.None, maxsplit: -1}, null, null),
1574
sep = $.sep,
1575
maxsplit = $.maxsplit,
1576
self = $.self,
1577
pos = 0
1578
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1579
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1580
if(sep === _b_.None){
1582
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1583
if(pos === self.length - 1){return [self]}
1584
var name = ""
1586
if(self.charAt(pos).search(/\s/) == -1){
1587
if(name == ""){name = self.charAt(pos)}
1588
else{name += self.charAt(pos)}
1608
var res = [],
1609
s = "",
1610
seplen = sep.length
1611
if(maxsplit == 0){return [self]}
1612
while(pos < self.length){
1613
if(self.substr(pos, seplen) == sep){
1633
["self", "keepends"], arguments, {keepends: false}, null, null)
1634
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1635
throw _b_.TypeError.$factory("integer argument expected, got " +
1642
start = pos,
1643
pos = 0,
1644
self = $.self
1645
while(pos < self.length){
1646
if(self.substr(pos, 2) == "\r\n"){
1647
res.push(self.substring(start, pos + 2))
1648
start = pos + 2
1650
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1651
res.push(self.substring(start, pos + 1))
1652
start = pos + 1
1653
pos = start
1654
}else{pos++}
1655
}
1656
var rest = self.substr(start)
1657
if(rest){res.push(rest)}
1658
return res
1659
}else{
1666
// Return True if string starts with the prefix, otherwise return False.
1667
// prefix can also be a tuple of prefixes to look for. With optional
1668
// start, test string beginning at that position. With optional end,
1670
var $ = $B.args("startswith", 4,
1671
{self: null, prefix: null, start: null, end: null},
1672
["self", "prefix", "start", "end"],
1673
arguments, {start: 0, end: null}, null, null)
1680
var s = $.self.substring($.start, $.end)
1681
for(var i = 0, len = prefixes.length; i < len; i++){
1692
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1693
arguments, {chars: _b_.None}, null, null)
1694
if($.chars === _b_.None){return $.self.trim()}
1695
for(var i = 0; i < $.self.length; i++){
1696
if($.chars.indexOf($.self.charAt(i)) == -1){
1697
break
1700
for(var j = $.self.length - 1; j >= i; j--){
1701
if($.chars.indexOf($.self.charAt(j)) == -1){
1702
break
1710
getitem = $B.$getattr(table, "__getitem__")
1711
for(var i = 0, len = self.length; i < len; i++){
1712
try{
1713
var repl = getitem(self.charCodeAt(i))
1714
if(repl !== _b_.None){
1726
["self", "width"], arguments, {}, null, null)
1727
if($.width <= self.length){return self}
1729
case "+":
1730
case "-":
1731
return self.charAt(0) +
1732
"0".repeat($.width - self.length) + self.substr(1)
1750
// class or its subclasses, but the attribute __str__ of the
1751
// class metaclass (usually "type") or its subclasses (usually
1752
// "object")
1753
// The metaclass is the attribute __class__ of the class dictionary
1757
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1758
encoding !== undefined){
1759
// str(bytes, encoding, errors) is equal to
1760
// bytes.decode(encoding, errors)
1761
// Arguments may be passed as keywords (cf. issue #1060)
1762
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
1763
["arg", "encoding", "errors"], arguments,
1764
{encoding: "utf-8", errors: "strict"}, null, null)
1765
return _b_.bytes.decode(arg, $.encoding, $.errors)
1767
var f = $B.$getattr(arg, "__str__", null)
1768
if(f === null ||
1769
// if not better than object.__str__, try __repr__
1770
(arg.__class__ && arg.__class__ !== _b_.object &&
1771
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1772
var f = $B.$getattr(arg, "__repr__")
1773
}
1778
if($B.debug > 1){console.log(err)}
1779
console.log("Warning - no method __str__ or __repr__, " +
1780
"default to toString", arg)
1781
return arg.toString()
1787
if(cls === undefined){
1788
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1812
var args = [],
1813
pos = 0
1814
if(arguments.length > 0){
1815
var args = [arguments[0].valueOf()],
1816
pos = 1
1817
for(var i = 1, len = arguments.length; i < len; i++){
1818
args[pos++] = arguments[i]
1834
// Function to parse the 2nd argument of format()
1835
$B.parse_format_spec = function(spec){
1838
var pos = 0,
1839
aligns = "<>=^",
1840
digits = "0123456789",
1841
types = "bcdeEfFgGnosxX%",
1843
if(align_pos != -1){
1844
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1845
// If the second char is also an alignment specifier, the
1846
// first char is the fill value
1847
this.fill = spec.charAt(0)
1848
this.align = spec.charAt(1)
1849
pos = 2
1850
}else{
1851
// The first character defines alignment : fill defaults to ' '
1866
if(car == "+" || car == "-" || car == " "){
1867
this.sign = car
1868
pos++
1869
car = spec.charAt(pos)
1871
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1872
if(car == "0"){
1881
while(car && digits.indexOf(car) > -1){
1882
if(this.width === undefined){this.width = car}
1883
else{this.width += car}
1884
pos++
1885
car = spec.charAt(pos)
1888
if(this.width === undefined && car == "{"){
1889
// Width is determined by a parameter
1890
var end_param_pos = spec.substr(pos).search("}")
1891
this.width = spec.substring(pos, end_param_pos)
1892
console.log("width", "[" + this.width + "]")
1893
pos += end_param_pos + 1
1894
}
1895
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1896
if(car == "."){
1897
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1898
throw _b_.ValueError.$factory(
1899
"Missing precision in format spec")
1901
this.precision = spec.charAt(pos + 1)
1902
pos += 2
1903
car = spec.charAt(pos)
1904
while(car && digits.indexOf(car) > -1){
1911
if(car && types.indexOf(car) > -1){
1912
this.type = car
1913
pos++
1914
car = spec.charAt(pos)
1915
}
1916
if(pos !== spec.length){
1922
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1923
(this.align || "") +
1924
(this.sign || "") +
1925
(this.alternate ? "#" : "") +
1926
(this.sign_aware ? "0" : "") +
1927
(this.width || "") +
1928
(this.comma ? "," : "") +
1929
(this.precision ? "." + this.precision : "") +
1930
(this.type || "")
1935
if(fmt.width && s.length < fmt.width){
1936
var fill = fmt.fill || " ",
1937
align = fmt.align || "<",
1938
missing = fmt.width - s.length
1940
case "<":
1941
return s + fill.repeat(missing)
1942
case ">":
1943
return fill.repeat(missing) + s
1944
case "=":
1945
if("+-".indexOf(s.charAt(0)) > -1){
1946
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1950
case "^":
1951
var left = parseInt(missing / 2)
1952
return fill.repeat(left) + s + fill.repeat(missing - left)
1965
$B.parse_fstring = function(string){
1966
// Parse a f-string
1967
var elts = [],
1968
pos = 0,
1992
}else{
1993
throw Error(" f-string: single '}' is not allowed")
1994
}
1995
}else{
2017
current += car
2018
i += 2
2019
}else{
2020
throw Error(" f-string: single '}' is not allowed")
2021
}
2022
}else{
2023
current += car
2024
i++
2025
}
2026
}
2028
}else{
2029
// End of expression is the } matching the opening {
2030
// There may be nested braces
2031
var i = pos,
2032
nb_braces = 1,
2054
// backslash is not allowed in expressions
2055
throw Error("f-string expression part cannot include a" +
2056
" backslash")
2063
throw Error("f-string: invalid conversion character:" +
2064
" expected 's', 'r', or 'a'")
2065
}else{
2079
if(string.substr(i, 3) == '"""'){
2080
var end = string.indexOf('"""', i + 3)
2081
if(end == -1){
2082
throw Error("f-string: unterminated string")
2083
}else{
2084
var trs = string.substring(i, end + 3)
2085
trs = trs.replace("\n", "\\n\\")
2090
var end = string.indexOf('"', i + 1)
2091
if(end == -1){
2092
throw Error("f-string: unterminated string")
2093
}else{
2094
current.expression += string.substring(i, end + 1)
2095
i = end + 1