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
Apr 16, 2019
Mar 19, 2018
Apr 16, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Nov 12, 2018
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Apr 2, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
May 24, 2019
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
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
2124 lines (1949 sloc)
67.5 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
// Can't use string.substring(start, end) because if end < start,
1050
// Javascript transforms it into substring(end, start)...
1051
var s = ""
1052
for(var i = $.start; i < $.end; i++){
1053
s += $.self.charAt(i)
1054
}
1056
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1057
if(s.length + $.sub.length == 0){return -1}
1059
var last_search = s.length - $.sub.length
1060
for(var i = 0; i <= last_search; i++){
1061
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1072
// a.x[z]!r:...
1073
// the object has attributes :
1074
// - name : "a"
1075
// - name_ext : [".x", "[z]"]
1076
// - conv : r
1077
// - spec : rest of string after :
1085
// No : in the string : it only contains a name
1086
name = fmt_string
1087
}else{
1088
// name is before the first ":"
1089
// spec (the format specification) is after
1090
name = elts[0]
1094
var elts = name.split("!")
1095
if(elts.length > 1){
1096
name = elts[0]
1097
conv = elts[1] // conversion flag
1101
// "name' may be a subscription or attribute
1102
// Put these "extensions" in the list "name_ext"
1103
function name_repl(match){
1104
name_ext.push(match)
1106
}
1107
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1108
name = name.replace(name_ext_re, name_repl)
1109
}
1116
// Parse self to detect formatting instructions
1117
// Create a list "parts" made of sections of the string :
1118
// - elements of even rank are literal text
1119
// - elements of odd rank are "format objects", built from the
1120
// format strings in self (of the form {...})
1131
text += "{"
1132
pos += 2
1133
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1140
// Store current literal text
1141
parts.push(text)
1142
1143
// Search the end of the format string, ie the } closing the
1144
// opening {. Since the string can contain other pairs {} for
1145
// nested formatting, an integer nb is incremented for each { and
1146
// decremented for each } ; the end of the format string is
1147
// reached when nb == 0
1148
var end = pos + 1,
1149
nb = 1
1150
while(end < _len){
1151
if(self.charAt(end) == "{"){nb++; end++}
1152
else if(self.charAt(end) == "}"){
1153
nb--; end++
1154
if(nb == 0){
1159
var fmt_obj = $B.parse_format(fmt_string)
1160
fmt_obj.raw_name = fmt_obj.name
1161
fmt_obj.raw_spec = fmt_obj.spec
1196
return parts
1197
}
1198
1199
str.format = function(self) {
1200
var $ = $B.args("format", 1, {self: null}, ["self"],
1201
arguments, {}, "$args", "$kw")
1202
1203
var parts = $B.split_format($.self)
1204
1215
1216
if(fmt.spec !== undefined){
1217
// "spec" may contain "nested replacement fields"
1218
// In this case, evaluate them using the positional
1219
// or keyword arguments passed to format()
1220
function replace_nested(name, key){
1221
if(/\d+/.exec(key)){
1222
// If key is numeric, search in positional
1223
// arguments
1224
return _b_.tuple.__getitem__($.$args,
1225
parseInt(key))
1226
}else{
1227
// Else try in keyword arguments
1228
return _b_.dict.__getitem__($.$kw, key)
1229
}
1230
}
1231
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1232
replace_nested)
1233
}
1235
// Numerical reference : use positional arguments
1236
var pos = parseInt(fmt.name),
1246
// Attribute
1247
value = _b_.getattr(value, ext.substr(1))
1248
}else{
1249
// Subscription
1252
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1253
value = _b_.getattr(value, "__getitem__")(key)
1257
// If the conversion flag is set, first call a function to convert
1258
// the value
1259
if(fmt.conv == "a"){value = _b_.ascii(value)}
1260
else if(fmt.conv == "r"){value = _b_.repr(value)}
1261
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1275
throw NotImplementedError.$factory(
1276
"function format_map not implemented yet")
1286
str.isascii = function(self){
1287
// Return true if the string is empty or all characters in the string are
1288
// ASCII, false otherwise. ASCII characters have code points in the range
1289
// U+0000-U+007F.
1290
for(var i = 0, len = self.length; i < len; i++){
1291
if(self.charCodeAt(i) > 127){return false}
1292
}
1293
return true
1294
}
1295
1306
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1307
"sequence item " + count + ": expected str instance, " +
1321
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1322
["self", "width", "fillchar"],
1323
arguments, {fillchar: " "}, null, null)
1330
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1331
arguments, {chars:_b_.None}, null, null)
1332
if($.chars === _b_.None){return $.self.trimLeft()}
1333
for(var i = 0; i < $.self.length; i++){
1334
if($.chars.indexOf($.self.charAt(i)) === -1){
1335
return $.self.substring(i)
1343
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1344
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1349
// If there is only one argument, it must be a dictionary mapping
1350
// Unicode ordinals (integers) or characters (strings of length 1) to
1351
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1353
if(! _b_.isinstance($.x, _b_.dict)){
1354
throw _b_.TypeError.$factory(
1355
"maketrans only argument must be a dict")
1358
for(var i = 0, len = items.length; i < len; i++){
1359
var k = items[i][0],
1360
v = items[i][1]
1361
if(! _b_.isinstance(k, _b_.int)){
1362
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1363
k = _b_.ord(k)
1364
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1367
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1368
throw _b_.TypeError.$factory("dictionary value " + v +
1376
// and in the resulting dictionary, each character in x will be mapped
1377
// to the character at the same position in y
1380
}else if($.x.length !== $.y.length){
1381
throw _b_.TypeError.$factory(
1382
"maketrans arguments must be strings or same length")
1388
if(! _b_.isinstance($.z, _b_.str)){
1389
throw _b_.TypeError.$factory(
1390
"maketrans third argument must be a string")
1412
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1413
arguments, {}, null, null)
1418
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1419
$.self.substring(i + $.sep.length)])
1420
}
1421
1422
function $re_escape(str){
1423
var specials = "[.*+?|()$^"
1424
for(var i = 0, len = specials.length; i < len; i++){
1425
var re = new RegExp("\\"+specials.charAt(i), "g")
1426
str = str.replace(re, "\\"+specials.charAt(i))
1427
}
1428
return str
1435
var $ = $B.args("replace", 4,
1436
{self: null, old: null, $$new: null, count: null},
1437
["self", "old", "$$new", "count"],
1438
arguments, {count: -1}, null, null),
1439
count = $.count,
1440
self = $.self,
1441
old = $.old,
1442
_new = $.$$new
1449
"' object cannot be interpreted as an integer")
1450
}else if(isinstance(count, _b_.float)){
1451
throw _b_.TypeError.$factory("integer argument expected, got float")
1452
}
1453
if(count == 0){return self}
1454
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1455
if(old == ""){
1456
if(_new == ""){return self}
1457
if(self == ""){return _new}
1458
var elts = self.split("")
1459
if(count > -1 && elts.length >= count){
1460
var rest = elts.slice(count).join("")
1461
return _new + elts.slice(0, count).join(_new) + rest
1462
}else{return _new + elts.join(_new) + _new}
1477
if(count < 0){count = res.length}
1478
while(count > 0){
1479
pos = res.indexOf(old, pos)
1480
if(pos < 0){break}
1481
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1482
pos = pos + _new.length
1483
count--
1489
// Return the highest index in the string where substring sub is found,
1490
// such that sub is contained within s[start:end]. Optional arguments
1492
if(arguments.length == 2 && typeof substr == "string"){
1493
return self.lastIndexOf(substr)
1494
}
1496
{self: null, sub: null, start: null, end: null},
1497
["self", "sub", "start", "end"],
1498
arguments, {start: 0, end: null}, null, null)
1510
for(var i = $.end - sublen; i >= $.start; i--){
1511
if($.self.substr(i, sublen) == $.sub){return i}
1518
var res = str.rfind.apply(null, arguments)
1519
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1524
var $ = $B.args("rjust",3,
1525
{self: null, width: null, fillchar: null},
1526
["self", "width", "fillchar"],
1527
arguments, {fillchar: " "}, null, null)
1535
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1536
arguments, {}, null, null)
1540
var items = str.partition(self, sep).reverse()
1541
for(var i = 0; i < items.length; i++){
1542
items[i] = items[i].split("").reverse().join("")
1548
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1549
["self", "sep", "maxsplit"], arguments,
1550
{sep: _b_.None, maxsplit: -1}, null, null),
1551
sep = $.sep
1554
var rev_str = reverse($.self),
1555
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1566
str.rstrip = function(self, x){
1567
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1568
arguments, {chars: _b_.None}, null, null)
1569
if($.chars === _b_.None){return $.self.trimRight()}
1571
if($.chars.indexOf($.self.charAt(j)) == -1){
1572
return $.self.substring(0, j + 1)
1579
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1580
["self", "sep", "maxsplit"], arguments,
1581
{sep: _b_.None, maxsplit: -1}, null, null),
1582
sep = $.sep,
1583
maxsplit = $.maxsplit,
1584
self = $.self,
1585
pos = 0
1586
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1587
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1588
if(sep === _b_.None){
1590
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1591
if(pos === self.length - 1){return [self]}
1592
var name = ""
1594
if(self.charAt(pos).search(/\s/) == -1){
1595
if(name == ""){name = self.charAt(pos)}
1596
else{name += self.charAt(pos)}
1616
var res = [],
1617
s = "",
1618
seplen = sep.length
1619
if(maxsplit == 0){return [self]}
1620
while(pos < self.length){
1621
if(self.substr(pos, seplen) == sep){
1641
["self", "keepends"], arguments, {keepends: false}, null, null)
1642
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1643
throw _b_.TypeError.$factory("integer argument expected, got " +
1650
start = pos,
1651
pos = 0,
1652
self = $.self
1653
while(pos < self.length){
1654
if(self.substr(pos, 2) == "\r\n"){
1655
res.push(self.substring(start, pos + 2))
1656
start = pos + 2
1658
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1659
res.push(self.substring(start, pos + 1))
1660
start = pos + 1
1661
pos = start
1662
}else{pos++}
1663
}
1664
var rest = self.substr(start)
1665
if(rest){res.push(rest)}
1666
return res
1667
}else{
1674
// Return True if string starts with the prefix, otherwise return False.
1675
// prefix can also be a tuple of prefixes to look for. With optional
1676
// start, test string beginning at that position. With optional end,
1678
var $ = $B.args("startswith", 4,
1679
{self: null, prefix: null, start: null, end: null},
1680
["self", "prefix", "start", "end"],
1681
arguments, {start: 0, end: null}, null, null)
1688
var s = $.self.substring($.start, $.end)
1689
for(var i = 0, len = prefixes.length; i < len; i++){
1700
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1701
arguments, {chars: _b_.None}, null, null)
1702
if($.chars === _b_.None){return $.self.trim()}
1703
for(var i = 0; i < $.self.length; i++){
1704
if($.chars.indexOf($.self.charAt(i)) == -1){
1705
break
1708
for(var j = $.self.length - 1; j >= i; j--){
1709
if($.chars.indexOf($.self.charAt(j)) == -1){
1710
break
1718
getitem = $B.$getattr(table, "__getitem__")
1719
for(var i = 0, len = self.length; i < len; i++){
1720
try{
1721
var repl = getitem(self.charCodeAt(i))
1722
if(repl !== _b_.None){
1734
["self", "width"], arguments, {}, null, null)
1735
if($.width <= self.length){return self}
1737
case "+":
1738
case "-":
1739
return self.charAt(0) +
1740
"0".repeat($.width - self.length) + self.substr(1)
1758
// class or its subclasses, but the attribute __str__ of the
1759
// class metaclass (usually "type") or its subclasses (usually
1760
// "object")
1761
// The metaclass is the attribute __class__ of the class dictionary
1765
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1766
encoding !== undefined){
1767
// str(bytes, encoding, errors) is equal to
1768
// bytes.decode(encoding, errors)
1769
// Arguments may be passed as keywords (cf. issue #1060)
1770
var $ = $B.args("str", 3, {arg: null, encoding: null, errors: null},
1771
["arg", "encoding", "errors"], arguments,
1772
{encoding: "utf-8", errors: "strict"}, null, null)
1773
return _b_.bytes.decode(arg, $.encoding, $.errors)
1775
var f = $B.$getattr(arg, "__str__", null)
1776
if(f === null ||
1777
// if not better than object.__str__, try __repr__
1778
(arg.__class__ && arg.__class__ !== _b_.object &&
1779
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1780
var f = $B.$getattr(arg, "__repr__")
1781
}
1786
if($B.debug > 1){console.log(err)}
1787
console.log("Warning - no method __str__ or __repr__, " +
1788
"default to toString", arg)
1795
if(cls === undefined){
1796
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1820
var args = [],
1821
pos = 0
1822
if(arguments.length > 0){
1823
var args = [arguments[0].valueOf()],
1824
pos = 1
1825
for(var i = 1, len = arguments.length; i < len; i++){
1826
args[pos++] = arguments[i]
1842
// Function to parse the 2nd argument of format()
1843
$B.parse_format_spec = function(spec){
1846
var pos = 0,
1847
aligns = "<>=^",
1848
digits = "0123456789",
1849
types = "bcdeEfFgGnosxX%",
1851
if(align_pos != -1){
1852
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1853
// If the second char is also an alignment specifier, the
1854
// first char is the fill value
1855
this.fill = spec.charAt(0)
1856
this.align = spec.charAt(1)
1857
pos = 2
1858
}else{
1859
// The first character defines alignment : fill defaults to ' '
1874
if(car == "+" || car == "-" || car == " "){
1875
this.sign = car
1876
pos++
1877
car = spec.charAt(pos)
1879
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1880
if(car == "0"){
1889
while(car && digits.indexOf(car) > -1){
1890
if(this.width === undefined){this.width = car}
1891
else{this.width += car}
1892
pos++
1893
car = spec.charAt(pos)
1896
if(this.width === undefined && car == "{"){
1897
// Width is determined by a parameter
1898
var end_param_pos = spec.substr(pos).search("}")
1899
this.width = spec.substring(pos, end_param_pos)
1900
console.log("width", "[" + this.width + "]")
1901
pos += end_param_pos + 1
1902
}
1903
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1904
if(car == "."){
1905
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1906
throw _b_.ValueError.$factory(
1907
"Missing precision in format spec")
1909
this.precision = spec.charAt(pos + 1)
1910
pos += 2
1911
car = spec.charAt(pos)
1912
while(car && digits.indexOf(car) > -1){
1919
if(car && types.indexOf(car) > -1){
1920
this.type = car
1921
pos++
1922
car = spec.charAt(pos)
1923
}
1924
if(pos !== spec.length){
1930
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1931
(this.align || "") +
1932
(this.sign || "") +
1933
(this.alternate ? "#" : "") +
1934
(this.sign_aware ? "0" : "") +
1935
(this.width || "") +
1936
(this.comma ? "," : "") +
1937
(this.precision ? "." + this.precision : "") +
1938
(this.type || "")
1943
if(fmt.width && s.length < fmt.width){
1944
var fill = fmt.fill || " ",
1945
align = fmt.align || "<",
1946
missing = fmt.width - s.length
1948
case "<":
1949
return s + fill.repeat(missing)
1950
case ">":
1951
return fill.repeat(missing) + s
1952
case "=":
1953
if("+-".indexOf(s.charAt(0)) > -1){
1954
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1958
case "^":
1959
var left = parseInt(missing / 2)
1960
return fill.repeat(left) + s + fill.repeat(missing - left)
1973
$B.parse_fstring = function(string){
1974
// Parse a f-string
1975
var elts = [],
1976
pos = 0,
2000
}else{
2001
throw Error(" f-string: single '}' is not allowed")
2002
}
2003
}else{
2025
current += car
2026
i += 2
2027
}else{
2028
throw Error(" f-string: single '}' is not allowed")
2029
}
2030
}else{
2031
current += car
2032
i++
2033
}
2034
}
2036
}else{
2037
// End of expression is the } matching the opening {
2038
// There may be nested braces
2039
var i = pos,
2040
nb_braces = 1,
2062
// backslash is not allowed in expressions
2063
throw Error("f-string expression part cannot include a" +
2064
" backslash")
2071
throw Error("f-string: invalid conversion character:" +
2072
" expected 's', 'r', or 'a'")
2073
}else{
2087
if(string.substr(i, 3) == '"""'){
2088
var end = string.indexOf('"""', i + 3)
2089
if(end == -1){
2090
throw Error("f-string: unterminated string")
2091
}else{
2092
var trs = string.substring(i, end + 3)
2093
trs = trs.replace("\n", "\\n\\")
2098
var end = string.indexOf('"', i + 1)
2099
if(end == -1){
2100
throw Error("f-string: unterminated string")
2101
}else{
2102
current.expression += string.substring(i, end + 1)
2103
i = end + 1