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
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 19, 2018
Mar 19, 2018
Feb 9, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 12, 2018
Nov 12, 2018
Nov 12, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jan 6, 2016
Mar 19, 2018
Mar 19, 2018
Dec 10, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Aug 31, 2017
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Nov 14, 2018
Mar 19, 2018
Mar 19, 2018
Mar 19, 2018
Jul 28, 2018
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
2090 lines (1919 sloc)
66.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
214
if(x == -1){
215
x = -2
216
}
217
return x
218
}
219
220
str.__hash__ = function(self) {
221
return fnv(self)
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")
839
if(res.search('"') == -1 && res.search("'") == -1){
840
return "'" + res + "'"
841
}else if(self.search('"') == -1){
842
return '"' + res + '"'
843
}
844
var qesc = new RegExp("'", "g") // to escape single quote
845
res = "'" + res.replace(qesc, "\\'") + "'"
849
str.__setitem__ = function(self, attr, value){
850
throw _b_.TypeError.$factory(
851
"'str' object does not support item assignment")
865
$comp_func += "" // source code
866
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
875
var $notimplemented = function(self, other){
876
throw NotImplementedError.$factory(
877
"OPERATOR not implemented for class str")
880
// Copy static methods from unicode
881
var from_unicode = [
882
"title",
883
"capitalize",
884
"casefold",
885
"islower",
886
"isupper",
887
"istitle",
888
"isspace",
889
"isalpha",
890
"isalnum",
891
"isdecimal",
892
"isdigit",
893
"isnumeric",
894
"isidentifier",
895
"isprintable",
896
"lower",
897
"swapcase",
898
"upper"
899
]
905
str.center = function(){
906
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
907
["self", "width", "fillchar"],
908
arguments, {fillchar:" "}, null, null),
909
self = $.self
921
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
922
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
930
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
931
else{_slice = _b_.slice.$factory($.start, $.self.length)}
936
if($.sub.length == 0){
937
if($.start == $.self.length){return 1}
938
else if(substr.length == 0){return 0}
939
return substr.length + 1
941
var n = 0,
942
pos = 0
943
while(pos < substr.length){
944
pos = substr.indexOf($.sub, pos)
945
if(pos >= 0){n++; pos += $.sub.length}
946
else{break}
958
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
959
res += String.fromCharCode(String.charCodeAt(char) + 13)
960
}else if(("m" < char && char <= "z") ||
961
("M" < char && char <= "Z")){
962
res += String.fromCharCode(String.charCodeAt(char) - 13)
971
// Return True if the string ends with the specified suffix, otherwise
972
// return False. suffix can also be a tuple of suffixes to look for.
973
// With optional start, test beginning at that position. With optional
977
["self", "suffix", "start", "end"],
978
arguments, {start: 0, end: null}, null, null)
985
var s = $.self.substring($.start, $.end)
986
for(var i = 0, len = suffixes.length; i < len; i++){
990
if(suffix.length <= s.length &&
991
s.substr(s.length - suffix.length) == suffix){return true}
997
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
998
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
999
var s = $B.$GetInt($.tabsize),
1000
col = 0,
1001
pos = 0,
1002
res = ""
1003
if(s == 1){return self.replace(/\t/g," ")}
1004
while(pos < self.length){
1012
res += car
1013
col = 0
1014
break
1015
default:
1016
res += car
1017
col++
1018
break
1019
}
1020
pos++
1021
}
1027
// Return the lowest index in the string where substring sub is found,
1028
// such that sub is contained in the slice s[start:end]. Optional
1029
// arguments start and end are interpreted as in slice notation.
1032
{self: null, sub: null, start: null, end: null},
1033
["self", "sub", "start", "end"],
1034
arguments, {start: 0, end: null}, null, null)
1038
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1039
throw _b_.TypeError.$factory("slice indices must be " +
1040
"integers or None or have an __index__ method")}
1041
var s = $.self.substring($.start, $.end)
1043
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1044
if(s.length + $.sub.length == 0){return -1}
1046
var last_search = s.length - $.sub.length
1047
for(var i = 0; i <= last_search; i++){
1048
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1059
// a.x[z]!r:...
1060
// the object has attributes :
1061
// - name : "a"
1062
// - name_ext : [".x", "[z]"]
1063
// - conv : r
1064
// - spec : rest of string after :
1072
// No : in the string : it only contains a name
1073
name = fmt_string
1074
}else{
1075
// name is before the first ":"
1076
// spec (the format specification) is after
1077
name = elts[0]
1081
var elts = name.split("!")
1082
if(elts.length > 1){
1083
name = elts[0]
1084
conv = elts[1] // conversion flag
1088
// "name' may be a subscription or attribute
1089
// Put these "extensions" in the list "name_ext"
1090
function name_repl(match){
1091
name_ext.push(match)
1093
}
1094
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1095
name = name.replace(name_ext_re, name_repl)
1096
}
1103
// Parse self to detect formatting instructions
1104
// Create a list "parts" made of sections of the string :
1105
// - elements of even rank are literal text
1106
// - elements of odd rank are "format objects", built from the
1107
// format strings in self (of the form {...})
1118
text += "{"
1119
pos += 2
1120
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1127
// Store current literal text
1128
parts.push(text)
1129
1130
// Search the end of the format string, ie the } closing the
1131
// opening {. Since the string can contain other pairs {} for
1132
// nested formatting, an integer nb is incremented for each { and
1133
// decremented for each } ; the end of the format string is
1134
// reached when nb == 0
1135
var end = pos + 1,
1136
nb = 1
1137
while(end < _len){
1138
if(self.charAt(end) == "{"){nb++; end++}
1139
else if(self.charAt(end) == "}"){
1140
nb--; end++
1141
if(nb == 0){
1146
var fmt_obj = $B.parse_format(fmt_string)
1147
fmt_obj.raw_name = fmt_obj.name
1148
fmt_obj.raw_spec = fmt_obj.spec
1183
return parts
1184
}
1185
1186
str.format = function(self) {
1187
var $ = $B.args("format", 1, {self: null}, ["self"],
1188
arguments, {}, "$args", "$kw")
1189
1190
var parts = $B.split_format($.self)
1191
1202
1203
if(fmt.spec !== undefined){
1204
// "spec" may contain "nested replacement fields"
1205
// In this case, evaluate them using the positional
1206
// or keyword arguments passed to format()
1207
function replace_nested(name, key){
1208
if(/\d+/.exec(key)){
1209
// If key is numeric, search in positional
1210
// arguments
1211
return _b_.tuple.__getitem__($.$args,
1212
parseInt(key))
1213
}else{
1214
// Else try in keyword arguments
1215
return _b_.dict.__getitem__($.$kw, key)
1216
}
1217
}
1218
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1219
replace_nested)
1220
}
1222
// Numerical reference : use positional arguments
1223
var pos = parseInt(fmt.name),
1233
// Attribute
1234
value = _b_.getattr(value, ext.substr(1))
1235
}else{
1236
// Subscription
1239
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1240
value = _b_.getattr(value, "__getitem__")(key)
1244
// If the conversion flag is set, first call a function to convert
1245
// the value
1246
if(fmt.conv == "a"){value = _b_.ascii(value)}
1247
else if(fmt.conv == "r"){value = _b_.repr(value)}
1248
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1262
throw NotImplementedError.$factory(
1263
"function format_map not implemented yet")
1283
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1284
"sequence item " + count + ": expected str instance, " +
1298
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1299
["self", "width", "fillchar"],
1300
arguments, {fillchar: " "}, null, null)
1307
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1308
arguments, {chars:_b_.None}, null, null)
1309
if($.chars === _b_.None){return $.self.trimLeft()}
1310
for(var i = 0; i < $.self.length; i++){
1311
if($.chars.indexOf($.self.charAt(i)) === -1){
1312
return $.self.substring(i)
1320
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1321
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1326
// If there is only one argument, it must be a dictionary mapping
1327
// Unicode ordinals (integers) or characters (strings of length 1) to
1328
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1330
if(! _b_.isinstance($.x, _b_.dict)){
1331
throw _b_.TypeError.$factory(
1332
"maketrans only argument must be a dict")
1335
for(var i = 0, len = items.length; i < len; i++){
1336
var k = items[i][0],
1337
v = items[i][1]
1338
if(! _b_.isinstance(k, _b_.int)){
1339
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1340
k = _b_.ord(k)
1341
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1344
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1345
throw _b_.TypeError.$factory("dictionary value " + v +
1353
// and in the resulting dictionary, each character in x will be mapped
1354
// to the character at the same position in y
1357
}else if($.x.length !== $.y.length){
1358
throw _b_.TypeError.$factory(
1359
"maketrans arguments must be strings or same length")
1365
if(! _b_.isinstance($.z, _b_.str)){
1366
throw _b_.TypeError.$factory(
1367
"maketrans third argument must be a string")
1374
var key = _b_.ord($.x.charAt(i)),
1375
value = $.y.charAt(i)
1376
_b_.dict.$setitem(_t, key, value)
1387
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1388
arguments, {}, null, null)
1393
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1394
$.self.substring(i + $.sep.length)])
1395
}
1396
1397
function $re_escape(str){
1398
var specials = "[.*+?|()$^"
1399
for(var i = 0, len = specials.length; i < len; i++){
1400
var re = new RegExp("\\"+specials.charAt(i), "g")
1401
str = str.replace(re, "\\"+specials.charAt(i))
1402
}
1403
return str
1410
var $ = $B.args("replace", 4,
1411
{self: null, old: null, $$new: null, count: null},
1412
["self", "old", "$$new", "count"],
1413
arguments, {count: -1}, null, null),
1414
count = $.count,
1415
self = $.self,
1416
old = $.old,
1417
_new = $.$$new
1424
"' object cannot be interpreted as an integer")
1425
}else if(isinstance(count, _b_.float)){
1426
throw _b_.TypeError.$factory("integer argument expected, got float")
1427
}
1428
if(count == 0){return self}
1429
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1430
if(old == ""){
1431
if(_new == ""){return self}
1432
if(self == ""){return _new}
1433
var elts = self.split("")
1434
if(count > -1 && elts.length >= count){
1435
var rest = elts.slice(count).join("")
1436
return _new + elts.slice(0, count).join(_new) + rest
1437
}else{return _new + elts.join(_new) + _new}
1452
if(count < 0){count = res.length}
1453
while(count > 0){
1454
pos = res.indexOf(old, pos)
1455
if(pos < 0){break}
1456
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1457
pos = pos + _new.length
1458
count--
1464
// Return the highest index in the string where substring sub is found,
1465
// such that sub is contained within s[start:end]. Optional arguments
1468
{self: null, sub: null, start: null, end: null},
1469
["self", "sub", "start", "end"],
1470
arguments, {start: 0, end: null}, null, null)
1482
for(var i = $.end - sublen; i >= $.start; i--){
1483
if($.self.substr(i, sublen) == $.sub){return i}
1490
var res = str.rfind.apply(null, arguments)
1491
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1496
var $ = $B.args("rjust",3,
1497
{self: null, width: null, fillchar: null},
1498
["self", "width", "fillchar"],
1499
arguments, {fillchar: " "}, null, null)
1507
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1508
arguments, {}, null, null)
1512
var items = str.partition(self, sep).reverse()
1513
for(var i = 0; i < items.length; i++){
1514
items[i] = items[i].split("").reverse().join("")
1520
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1521
["self", "sep", "maxsplit"], arguments,
1522
{sep: _b_.None, maxsplit: -1}, null, null),
1523
sep = $.sep
1526
var rev_str = reverse($.self),
1527
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1538
str.rstrip = function(self, x){
1539
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1540
arguments, {chars: _b_.None}, null, null)
1541
if($.chars === _b_.None){return $.self.trimRight()}
1543
if($.chars.indexOf($.self.charAt(j)) == -1){
1544
return $.self.substring(0, j + 1)
1551
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1552
["self", "sep", "maxsplit"], arguments,
1553
{sep: _b_.None, maxsplit: -1}, null, null),
1554
sep = $.sep,
1555
maxsplit = $.maxsplit,
1556
self = $.self,
1557
pos = 0
1558
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1559
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1560
if(sep === _b_.None){
1562
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1563
if(pos === self.length - 1){return [self]}
1564
var name = ""
1566
if(self.charAt(pos).search(/\s/) == -1){
1567
if(name == ""){name = self.charAt(pos)}
1568
else{name += self.charAt(pos)}
1588
var res = [],
1589
s = "",
1590
seplen = sep.length
1591
if(maxsplit == 0){return [self]}
1592
while(pos < self.length){
1593
if(self.substr(pos, seplen) == sep){
1613
["self", "keepends"], arguments, {keepends: false}, null, null)
1614
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1615
throw _b_.TypeError.$factory("integer argument expected, got " +
1622
start = pos,
1623
pos = 0,
1624
self = $.self
1625
while(pos < self.length){
1626
if(self.substr(pos, 2) == "\r\n"){
1627
res.push(self.substring(start, pos + 2))
1628
start = pos + 2
1630
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1631
res.push(self.substring(start, pos + 1))
1632
start = pos + 1
1633
pos = start
1634
}else{pos++}
1635
}
1636
var rest = self.substr(start)
1637
if(rest){res.push(rest)}
1638
return res
1639
}else{
1646
// Return True if string starts with the prefix, otherwise return False.
1647
// prefix can also be a tuple of prefixes to look for. With optional
1648
// start, test string beginning at that position. With optional end,
1650
var $ = $B.args("startswith", 4,
1651
{self: null, prefix: null, start: null, end: null},
1652
["self", "prefix", "start", "end"],
1653
arguments, {start: 0, end: null}, null, null)
1660
var s = $.self.substring($.start, $.end)
1661
for(var i = 0, len = prefixes.length; i < len; i++){
1672
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1673
arguments, {chars: _b_.None}, null, null)
1674
if($.chars === _b_.None){return $.self.trim()}
1675
for(var i = 0; i < $.self.length; i++){
1676
if($.chars.indexOf($.self.charAt(i)) == -1){
1677
break
1680
for(var j = $.self.length - 1; j >= i; j--){
1681
if($.chars.indexOf($.self.charAt(j)) == -1){
1682
break
1690
getitem = $B.$getattr(table, "__getitem__")
1691
for(var i = 0, len = self.length; i < len; i++){
1692
try{
1693
var repl = getitem(self.charCodeAt(i))
1694
if(repl !== _b_.None){
1695
res.push(repl)
1696
}
1697
}catch(err){
1698
res.push(self.charAt(i))
1699
}
1706
["self", "width"], arguments, {}, null, null)
1707
if($.width <= self.length){return self}
1709
case "+":
1710
case "-":
1711
return self.charAt(0) +
1712
"0".repeat($.width - self.length) + self.substr(1)
1721
case "string":
1722
return arg
1723
case "number":
1724
if(isFinite(arg)){return arg.toString()}
1730
// class or its subclasses, but the attribute __str__ of the
1731
// class metaclass (usually "type") or its subclasses (usually
1732
// "object")
1733
// The metaclass is the attribute __class__ of the class dictionary
1737
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1738
encoding !== undefined){
1739
// str(bytes, encoding, errors) is equal to
1740
// bytes.decode(encoding, errors)
1741
return _b_.bytes.decode(arg, encoding || "utf-8",
1742
errors || "strict")
1743
}
1744
var f = $B.$getattr(arg, "__str__", null)
1745
if(f === null ||
1746
// if not better than object.__str__, try __repr__
1747
(arg.__class__ && arg.__class__ !== _b_.object &&
1748
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1749
var f = $B.$getattr(arg, "__repr__")
1750
}
1755
if($B.debug > 1){console.log(err)}
1756
console.log("Warning - no method __str__ or __repr__, " +
1757
"default to toString", arg)
1758
return arg.toString()
1764
if(cls === undefined){
1765
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1789
var args = [],
1790
pos = 0
1791
if(arguments.length > 0){
1792
var args = [arguments[0].valueOf()],
1793
pos = 1
1794
for(var i = 1, len = arguments.length; i < len; i++){
1795
args[pos++] = arguments[i]
1811
// Function to parse the 2nd argument of format()
1812
$B.parse_format_spec = function(spec){
1815
var pos = 0,
1816
aligns = "<>=^",
1817
digits = "0123456789",
1818
types = "bcdeEfFgGnosxX%",
1820
if(align_pos != -1){
1821
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1822
// If the second char is also an alignment specifier, the
1823
// first char is the fill value
1824
this.fill = spec.charAt(0)
1825
this.align = spec.charAt(1)
1826
pos = 2
1827
}else{
1828
// The first character defines alignment : fill defaults to ' '
1843
if(car == "+" || car == "-" || car == " "){
1844
this.sign = car
1845
pos++
1846
car = spec.charAt(pos)
1848
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1849
if(car == "0"){
1856
while(car && digits.indexOf(car) > -1){
1857
if(this.width === undefined){this.width = car}
1858
else{this.width += car}
1859
pos++
1860
car = spec.charAt(pos)
1863
if(this.width === undefined && car == "{"){
1864
// Width is determined by a parameter
1865
var end_param_pos = spec.substr(pos).search("}")
1866
this.width = spec.substring(pos, end_param_pos)
1867
console.log("width", "[" + this.width + "]")
1868
pos += end_param_pos + 1
1869
}
1870
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1871
if(car == "."){
1872
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1873
throw _b_.ValueError.$factory(
1874
"Missing precision in format spec")
1876
this.precision = spec.charAt(pos + 1)
1877
pos += 2
1878
car = spec.charAt(pos)
1879
while(car && digits.indexOf(car) > -1){
1886
if(car && types.indexOf(car) > -1){
1887
this.type = car
1888
pos++
1889
car = spec.charAt(pos)
1890
}
1891
if(pos !== spec.length){
1896
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1897
(this.align || "") +
1898
(this.sign || "") +
1899
(this.alternate ? "#" : "") +
1900
(this.sign_aware ? "0" : "") +
1901
(this.width || "") +
1902
(this.comma ? "," : "") +
1903
(this.precision ? "." + this.precision : "") +
1904
(this.type || "")
1909
if(fmt.width && s.length < fmt.width){
1910
var fill = fmt.fill || " ",
1911
align = fmt.align || "<",
1912
missing = fmt.width - s.length
1914
case "<":
1915
return s + fill.repeat(missing)
1916
case ">":
1917
return fill.repeat(missing) + s
1918
case "=":
1919
if("+-".indexOf(s.charAt(0)) > -1){
1920
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1924
case "^":
1925
var left = parseInt(missing / 2)
1926
return fill.repeat(left) + s + fill.repeat(missing - left)
1939
$B.parse_fstring = function(string){
1940
// Parse a f-string
1941
var elts = [],
1942
pos = 0,
1966
}else{
1967
throw Error(" f-string: single '}' is not allowed")
1968
}
1969
}else{
1991
current += car
1992
i += 2
1993
}else{
1994
throw Error(" f-string: single '}' is not allowed")
1995
}
1996
}else{
1997
current += car
1998
i++
1999
}
2000
}
2002
}else{
2003
// End of expression is the } matching the opening {
2004
// There may be nested braces
2005
var i = pos,
2006
nb_braces = 1,
2028
// backslash is not allowed in expressions
2029
throw Error("f-string expression part cannot include a" +
2030
" backslash")
2037
throw Error("f-string: invalid conversion character:" +
2038
" expected 's', 'r', or 'a'")
2039
}else{
2053
if(string.substr(i, 3) == '"""'){
2054
var end = string.indexOf('"""', i + 3)
2055
if(end == -1){
2056
throw Error("f-string: unterminated string")
2057
}else{
2058
var trs = string.substring(i, end + 3)
2059
trs = trs.replace("\n", "\\n\\")
2064
var end = string.indexOf('"', i + 1)
2065
if(end == -1){
2066
throw Error("f-string: unterminated string")
2067
}else{
2068
current.expression += string.substring(i, end + 1)
2069
i = end + 1