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
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
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
2104 lines (1931 sloc)
66.8 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}
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")
1291
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1292
"sequence item " + count + ": expected str instance, " +
1306
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1307
["self", "width", "fillchar"],
1308
arguments, {fillchar: " "}, null, null)
1315
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1316
arguments, {chars:_b_.None}, null, null)
1317
if($.chars === _b_.None){return $.self.trimLeft()}
1318
for(var i = 0; i < $.self.length; i++){
1319
if($.chars.indexOf($.self.charAt(i)) === -1){
1320
return $.self.substring(i)
1328
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1329
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1334
// If there is only one argument, it must be a dictionary mapping
1335
// Unicode ordinals (integers) or characters (strings of length 1) to
1336
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1338
if(! _b_.isinstance($.x, _b_.dict)){
1339
throw _b_.TypeError.$factory(
1340
"maketrans only argument must be a dict")
1343
for(var i = 0, len = items.length; i < len; i++){
1344
var k = items[i][0],
1345
v = items[i][1]
1346
if(! _b_.isinstance(k, _b_.int)){
1347
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1348
k = _b_.ord(k)
1349
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1352
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1353
throw _b_.TypeError.$factory("dictionary value " + v +
1361
// and in the resulting dictionary, each character in x will be mapped
1362
// to the character at the same position in y
1365
}else if($.x.length !== $.y.length){
1366
throw _b_.TypeError.$factory(
1367
"maketrans arguments must be strings or same length")
1373
if(! _b_.isinstance($.z, _b_.str)){
1374
throw _b_.TypeError.$factory(
1375
"maketrans third argument must be a string")
1382
var key = _b_.ord($.x.charAt(i)),
1383
value = $.y.charAt(i)
1384
_b_.dict.$setitem(_t, key, value)
1395
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1396
arguments, {}, null, null)
1401
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1402
$.self.substring(i + $.sep.length)])
1403
}
1404
1405
function $re_escape(str){
1406
var specials = "[.*+?|()$^"
1407
for(var i = 0, len = specials.length; i < len; i++){
1408
var re = new RegExp("\\"+specials.charAt(i), "g")
1409
str = str.replace(re, "\\"+specials.charAt(i))
1410
}
1411
return str
1418
var $ = $B.args("replace", 4,
1419
{self: null, old: null, $$new: null, count: null},
1420
["self", "old", "$$new", "count"],
1421
arguments, {count: -1}, null, null),
1422
count = $.count,
1423
self = $.self,
1424
old = $.old,
1425
_new = $.$$new
1432
"' object cannot be interpreted as an integer")
1433
}else if(isinstance(count, _b_.float)){
1434
throw _b_.TypeError.$factory("integer argument expected, got float")
1435
}
1436
if(count == 0){return self}
1437
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1438
if(old == ""){
1439
if(_new == ""){return self}
1440
if(self == ""){return _new}
1441
var elts = self.split("")
1442
if(count > -1 && elts.length >= count){
1443
var rest = elts.slice(count).join("")
1444
return _new + elts.slice(0, count).join(_new) + rest
1445
}else{return _new + elts.join(_new) + _new}
1460
if(count < 0){count = res.length}
1461
while(count > 0){
1462
pos = res.indexOf(old, pos)
1463
if(pos < 0){break}
1464
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1465
pos = pos + _new.length
1466
count--
1472
// Return the highest index in the string where substring sub is found,
1473
// such that sub is contained within s[start:end]. Optional arguments
1476
{self: null, sub: null, start: null, end: null},
1477
["self", "sub", "start", "end"],
1478
arguments, {start: 0, end: null}, null, null)
1490
for(var i = $.end - sublen; i >= $.start; i--){
1491
if($.self.substr(i, sublen) == $.sub){return i}
1498
var res = str.rfind.apply(null, arguments)
1499
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1504
var $ = $B.args("rjust",3,
1505
{self: null, width: null, fillchar: null},
1506
["self", "width", "fillchar"],
1507
arguments, {fillchar: " "}, null, null)
1515
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1516
arguments, {}, null, null)
1520
var items = str.partition(self, sep).reverse()
1521
for(var i = 0; i < items.length; i++){
1522
items[i] = items[i].split("").reverse().join("")
1528
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1529
["self", "sep", "maxsplit"], arguments,
1530
{sep: _b_.None, maxsplit: -1}, null, null),
1531
sep = $.sep
1534
var rev_str = reverse($.self),
1535
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1546
str.rstrip = function(self, x){
1547
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1548
arguments, {chars: _b_.None}, null, null)
1549
if($.chars === _b_.None){return $.self.trimRight()}
1551
if($.chars.indexOf($.self.charAt(j)) == -1){
1552
return $.self.substring(0, j + 1)
1559
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1560
["self", "sep", "maxsplit"], arguments,
1561
{sep: _b_.None, maxsplit: -1}, null, null),
1562
sep = $.sep,
1563
maxsplit = $.maxsplit,
1564
self = $.self,
1565
pos = 0
1566
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1567
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1568
if(sep === _b_.None){
1570
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1571
if(pos === self.length - 1){return [self]}
1572
var name = ""
1574
if(self.charAt(pos).search(/\s/) == -1){
1575
if(name == ""){name = self.charAt(pos)}
1576
else{name += self.charAt(pos)}
1596
var res = [],
1597
s = "",
1598
seplen = sep.length
1599
if(maxsplit == 0){return [self]}
1600
while(pos < self.length){
1601
if(self.substr(pos, seplen) == sep){
1621
["self", "keepends"], arguments, {keepends: false}, null, null)
1622
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1623
throw _b_.TypeError.$factory("integer argument expected, got " +
1630
start = pos,
1631
pos = 0,
1632
self = $.self
1633
while(pos < self.length){
1634
if(self.substr(pos, 2) == "\r\n"){
1635
res.push(self.substring(start, pos + 2))
1636
start = pos + 2
1638
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1639
res.push(self.substring(start, pos + 1))
1640
start = pos + 1
1641
pos = start
1642
}else{pos++}
1643
}
1644
var rest = self.substr(start)
1645
if(rest){res.push(rest)}
1646
return res
1647
}else{
1654
// Return True if string starts with the prefix, otherwise return False.
1655
// prefix can also be a tuple of prefixes to look for. With optional
1656
// start, test string beginning at that position. With optional end,
1658
var $ = $B.args("startswith", 4,
1659
{self: null, prefix: null, start: null, end: null},
1660
["self", "prefix", "start", "end"],
1661
arguments, {start: 0, end: null}, null, null)
1668
var s = $.self.substring($.start, $.end)
1669
for(var i = 0, len = prefixes.length; i < len; i++){
1680
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1681
arguments, {chars: _b_.None}, null, null)
1682
if($.chars === _b_.None){return $.self.trim()}
1683
for(var i = 0; i < $.self.length; i++){
1684
if($.chars.indexOf($.self.charAt(i)) == -1){
1685
break
1688
for(var j = $.self.length - 1; j >= i; j--){
1689
if($.chars.indexOf($.self.charAt(j)) == -1){
1690
break
1698
getitem = $B.$getattr(table, "__getitem__")
1699
for(var i = 0, len = self.length; i < len; i++){
1700
try{
1701
var repl = getitem(self.charCodeAt(i))
1702
if(repl !== _b_.None){
1703
res.push(repl)
1704
}
1705
}catch(err){
1706
res.push(self.charAt(i))
1707
}
1714
["self", "width"], arguments, {}, null, null)
1715
if($.width <= self.length){return self}
1717
case "+":
1718
case "-":
1719
return self.charAt(0) +
1720
"0".repeat($.width - self.length) + self.substr(1)
1738
// class or its subclasses, but the attribute __str__ of the
1739
// class metaclass (usually "type") or its subclasses (usually
1740
// "object")
1741
// The metaclass is the attribute __class__ of the class dictionary
1745
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1746
encoding !== undefined){
1747
// str(bytes, encoding, errors) is equal to
1748
// bytes.decode(encoding, errors)
1749
// Arguments may be passed as keywords (cf. issue #1060)
1750
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
1751
["arg", "encoding", "errors"], arguments,
1752
{encoding: "utf-8", errors: "strict"}, null, null)
1753
return _b_.bytes.decode(arg, $.encoding, $.errors)
1755
var f = $B.$getattr(arg, "__str__", null)
1756
if(f === null ||
1757
// if not better than object.__str__, try __repr__
1758
(arg.__class__ && arg.__class__ !== _b_.object &&
1759
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1760
var f = $B.$getattr(arg, "__repr__")
1761
}
1766
if($B.debug > 1){console.log(err)}
1767
console.log("Warning - no method __str__ or __repr__, " +
1768
"default to toString", arg)
1769
return arg.toString()
1775
if(cls === undefined){
1776
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1800
var args = [],
1801
pos = 0
1802
if(arguments.length > 0){
1803
var args = [arguments[0].valueOf()],
1804
pos = 1
1805
for(var i = 1, len = arguments.length; i < len; i++){
1806
args[pos++] = arguments[i]
1822
// Function to parse the 2nd argument of format()
1823
$B.parse_format_spec = function(spec){
1826
var pos = 0,
1827
aligns = "<>=^",
1828
digits = "0123456789",
1829
types = "bcdeEfFgGnosxX%",
1831
if(align_pos != -1){
1832
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1833
// If the second char is also an alignment specifier, the
1834
// first char is the fill value
1835
this.fill = spec.charAt(0)
1836
this.align = spec.charAt(1)
1837
pos = 2
1838
}else{
1839
// The first character defines alignment : fill defaults to ' '
1854
if(car == "+" || car == "-" || car == " "){
1855
this.sign = car
1856
pos++
1857
car = spec.charAt(pos)
1859
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1860
if(car == "0"){
1869
while(car && digits.indexOf(car) > -1){
1870
if(this.width === undefined){this.width = car}
1871
else{this.width += car}
1872
pos++
1873
car = spec.charAt(pos)
1876
if(this.width === undefined && car == "{"){
1877
// Width is determined by a parameter
1878
var end_param_pos = spec.substr(pos).search("}")
1879
this.width = spec.substring(pos, end_param_pos)
1880
console.log("width", "[" + this.width + "]")
1881
pos += end_param_pos + 1
1882
}
1883
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1884
if(car == "."){
1885
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1886
throw _b_.ValueError.$factory(
1887
"Missing precision in format spec")
1889
this.precision = spec.charAt(pos + 1)
1890
pos += 2
1891
car = spec.charAt(pos)
1892
while(car && digits.indexOf(car) > -1){
1899
if(car && types.indexOf(car) > -1){
1900
this.type = car
1901
pos++
1902
car = spec.charAt(pos)
1903
}
1904
if(pos !== spec.length){
1910
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1911
(this.align || "") +
1912
(this.sign || "") +
1913
(this.alternate ? "#" : "") +
1914
(this.sign_aware ? "0" : "") +
1915
(this.width || "") +
1916
(this.comma ? "," : "") +
1917
(this.precision ? "." + this.precision : "") +
1918
(this.type || "")
1923
if(fmt.width && s.length < fmt.width){
1924
var fill = fmt.fill || " ",
1925
align = fmt.align || "<",
1926
missing = fmt.width - s.length
1928
case "<":
1929
return s + fill.repeat(missing)
1930
case ">":
1931
return fill.repeat(missing) + s
1932
case "=":
1933
if("+-".indexOf(s.charAt(0)) > -1){
1934
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1938
case "^":
1939
var left = parseInt(missing / 2)
1940
return fill.repeat(left) + s + fill.repeat(missing - left)
1953
$B.parse_fstring = function(string){
1954
// Parse a f-string
1955
var elts = [],
1956
pos = 0,
1980
}else{
1981
throw Error(" f-string: single '}' is not allowed")
1982
}
1983
}else{
2005
current += car
2006
i += 2
2007
}else{
2008
throw Error(" f-string: single '}' is not allowed")
2009
}
2010
}else{
2011
current += car
2012
i++
2013
}
2014
}
2016
}else{
2017
// End of expression is the } matching the opening {
2018
// There may be nested braces
2019
var i = pos,
2020
nb_braces = 1,
2042
// backslash is not allowed in expressions
2043
throw Error("f-string expression part cannot include a" +
2044
" backslash")
2051
throw Error("f-string: invalid conversion character:" +
2052
" expected 's', 'r', or 'a'")
2053
}else{
2067
if(string.substr(i, 3) == '"""'){
2068
var end = string.indexOf('"""', i + 3)
2069
if(end == -1){
2070
throw Error("f-string: unterminated string")
2071
}else{
2072
var trs = string.substring(i, end + 3)
2073
trs = trs.replace("\n", "\\n\\")
2078
var end = string.indexOf('"', i + 1)
2079
if(end == -1){
2080
throw Error("f-string: unterminated string")
2081
}else{
2082
current.expression += string.substring(i, end + 1)
2083
i = end + 1