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
Feb 10, 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
Mar 19, 2018
Feb 9, 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
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
Mar 19, 2018
Jan 6, 2016
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
2073 lines (1902 sloc)
66.1 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)
76
if($.start === null || $.start === _b_.None){$.start = 0}
77
else if($.start < 0){
78
$.start += $.self.length
79
$.start = Math.max(0, $.start)
80
}
81
if($.end === null || $.end === _b_.None){$.end = $.self.length}
82
else if($.end < 0){
83
$.end += $.self.length
84
$.end = Math.max(0, $.end)
85
}
87
if(! isinstance($.start, _b_.int) || ! isinstance($.end, _b_.int)){
88
throw _b_.TypeError.$factory("slice indices must be integers " +
89
"or None or have an __index__ method")
90
}
107
if(!(typeof other === "string")){
108
try{return getattr(other, "__radd__")(self)}
109
catch(err){
110
throw _b_.TypeError.$factory("Can't convert " +
116
str.__contains__ = function(self, item){
117
if(!(typeof item == "string")){
118
throw _b_.TypeError.$factory("'in <string>' requires " +
119
"string as left operand, not " + item.__class__)
120
}
122
if(nbcar == 0) {return true} // a string contains the empty string
123
if(self.length == 0){return nbcar == 0}
124
for(var i = 0, len = self.length; i < len; i++){
125
if(self.substr(i, nbcar) == item){return true}
134
// __dir__must be assigned explicitely because attribute resolution for
135
// builtin classes doesn't use __mro__
139
if(other === undefined){ // compare object "self" to class "str"
140
return self === str
150
if(fmt.type && fmt.type != "s"){
151
throw _b_.ValueError.$factory("Unknown format code '" + fmt.type +
159
if(fmt.sign !== undefined){
160
throw _b_.ValueError.$factory(
161
"Sign not allowed in string format specifier")
171
if(arg < 0) {pos += self.length}
172
if(pos >= 0 && pos < self.length){return self.charAt(pos)}
173
throw _b_.IndexError.$factory("string index out of range")
174
}
175
if(isinstance(arg, slice)) {
176
var s = _b_.slice.$conv_for_seq(arg, self.length),
177
start = s.start,
178
stop = s.stop,
179
step = s.step
180
var res = "",
182
if(step > 0){
183
if(stop <= start){return ""}
184
for(var i = start; i < stop; i += step){res += self.charAt(i)}
186
if(stop >= start){return ''}
187
for(var i = start; i > stop; i += step){res += self.charAt(i)}
197
return str.__hashvalue__ || $B.$py_next_hash-- // for hash of string type (not instance of string)
200
//http://stackoverflow.com/questions/2909106/python-whats-a-correct-and-good-way-to-implement-hash
201
// this implementation for strings maybe good enough for us..
202
219
var items = self.split("") // list of all characters in string
220
return $B.$iterator(items, $str_iterator)
257
// left adjusted
258
return s + get_char_array(padding - s.length, flags.pad_char)
259
}
260
}
261
269
if(val.__class__ === $B.long_int){
270
s = $B.long_int.to_base(val, 10)
271
}else{
272
s = val.toString()
274
if(s[0] === "-"){
275
return "-" + get_char_array(precision - s.length + 1, "0") + s.slice(1)
286
if(val === Infinity){
287
val = "inf"
288
}else if(val === -Infinity){
289
val = "-inf"
290
}else{
291
val = "nan"
313
var str_format = function(val, flags) {
314
// string format supports left and right padding
315
flags.pad_char = " " // even if 0 padding is defined, don't use it
321
if(val.__class__ === $B.long_int){
322
val = $B.long_int.to_base(val, 10)
323
}else{
324
val = parseInt(val)
342
var repr_format = function(val, flags) {
343
flags.pad_char = " " // even if 0 padding is defined, don't use it
344
return format_padding(repr(val), flags)
345
}
347
var ascii_format = function(val, flags) {
348
flags.pad_char = " " // even if 0 padding is defined, don't use it
349
return format_padding(ascii(val), flags)
350
}
362
flags.precision = parseInt(flags.precision, 10)
363
validate_precision(flags.precision)
364
}
365
return parseFloat(val)
366
}
369
var trailing_zeros = /(.*?)(0+)([eE].*)/,
370
leading_zeros = /\.(0*)/,
371
trailing_dot = /\.$/
373
var validate_precision = function(precision) {
374
// force precision to limits of javascript
379
var floating_point_format = function(val, upper, flags){
380
val = _float_helper(val, flags),
381
v = val.toString(),
382
v_len = v.length,
383
dot_idx = v.indexOf('.')
384
if(dot_idx < 0){dot_idx = v_len}
385
if(val < 1 && val > -1){
386
var zeros = leading_zeros.exec(v),
387
numzeros
388
if(zeros){
393
if(numzeros >= 4){
394
val = format_sign(val, flags) + format_float_precision(val, upper,
395
flags, _floating_g_exp_helper)
396
if(!flags.alternate){
409
return format_padding(format_sign(val, flags) +
410
format_float_precision(val, upper, flags,
411
function(val, precision) {
412
return val.toFixed(min(precision, v_len - dot_idx) +
413
numzeros)
414
}),
415
flags
416
)
417
}
418
419
if(dot_idx > flags.precision){
420
val = format_sign(val, flags) + format_float_precision(val, upper,
421
flags, _floating_g_exp_helper)
422
if(! flags.alternate){
434
return format_padding(format_sign(val, flags) +
435
format_float_precision(val, upper, flags,
436
function(val, precision) {
437
if(!flags.decimal_point){
438
precision = min(v_len - 1, 6)
439
}else if (precision > v_len){
440
if(! flags.alternate){
441
precision = v_len
442
}
444
if(precision < dot_idx){
445
precision = dot_idx
446
}
447
return val.toFixed(precision - dot_idx)
448
}),
449
flags
450
)
453
var _floating_g_exp_helper = function(val, precision, flags, upper){
454
if(precision){--precision}
457
var e_idx = val.lastIndexOf("e")
458
if(e_idx > val.length - 4){
459
val = val.substring(0, e_idx + 2) + "0" + val.substring(e_idx + 2)
462
return val
463
}
464
465
// fF
466
var floating_point_decimal_format = function(val, upper, flags) {
467
val = _float_helper(val, flags)
468
return format_padding(format_sign(val, flags) +
469
format_float_precision(val, upper, flags,
470
function(val, precision, flags) {
471
val = val.toFixed(precision)
472
if(precision === 0 && flags.alternate){
473
val += '.'
474
}
475
return val
476
}),
477
flags
478
)
479
}
480
481
var _floating_exp_helper = function(val, precision, flags, upper) {
482
val = val.toExponential(precision)
483
// pad exponent to two digits
496
return format_padding(format_sign(val, flags) +
497
format_float_precision(val, upper, flags, _floating_exp_helper), flags)
523
if(flags.alternate){
524
if(ret.charAt(0) === "-"){
525
if(upper){ret = "-0X" + ret.slice(1)}
526
else{ret = "-0x" + ret.slice(1)}
527
}else{
528
if(upper){ret = "0X" + ret}
529
else{ret = "0x" + ret}
539
if(val.__class__ === $B.long_int){
540
ret = $B.long_int.to_base(8)
541
}else{
542
ret = parseInt(val)
543
ret = ret.toString(8)
559
if(flags.alternate){
560
if(ret.charAt(0) === "-"){ret = "-0o" + ret.slice(1)}
561
else{ret = "0o" + ret}
566
var single_char_format = function(val, flags){
567
if(isinstance(val, str) && val.length == 1) return val
568
try{
576
var num_flag = function(c, flags){
577
if(c === "0" && ! flags.padding && ! flags.decimal_point && ! flags.left){
578
flags.pad_char = "0"
584
flags.precision = (flags.precision || "") + c
585
}
586
}
587
588
var decimal_point_flag = function(val, flags) {
590
// can only have one decimal point
591
throw new UnsupportedChar()
592
}
593
flags.decimal_point = true
594
}
595
596
var neg_flag = function(val, flags){
597
flags.pad_char = " " // overrides '0' flag
614
"s": str_format,
615
"d": num_format,
616
"i": num_format,
617
"u": num_format,
618
"o": octal_format,
619
"r": repr_format,
620
"a": ascii_format,
621
"g": function(val, flags){
622
return floating_point_format(val, false, flags)
623
},
624
"G": function(val, flags){return floating_point_format(val, true, flags)},
625
"f": function(val, flags){
626
return floating_point_decimal_format(val, false, flags)
627
},
628
"F": function(val, flags){
629
return floating_point_decimal_format(val, true, flags)
630
},
631
"e": function(val, flags){
632
return floating_point_exponential_format(val, false, flags)
633
},
634
"E": function(val, flags){
635
return floating_point_exponential_format(val, true, flags)
636
},
637
"x": function(val, flags){return signed_hex_format(val, false, flags)},
638
"X": function(val, flags){return signed_hex_format(val, true, flags)},
639
"c": single_char_format,
640
"0": function(val, flags){return num_flag("0", flags)},
641
"1": function(val, flags){return num_flag("1", flags)},
642
"2": function(val, flags){return num_flag("2", flags)},
643
"3": function(val, flags){return num_flag("3", flags)},
644
"4": function(val, flags){return num_flag("4", flags)},
645
"5": function(val, flags){return num_flag("5", flags)},
646
"6": function(val, flags){return num_flag("6", flags)},
647
"7": function(val, flags){return num_flag("7", flags)},
648
"8": function(val, flags){return num_flag("8", flags)},
649
"9": function(val, flags){return num_flag("9", flags)},
650
"-": neg_flag,
651
" ": space_flag,
652
"+": sign_flag,
653
".": decimal_point_flag,
654
"#": alternate_flag
655
}
656
657
// exception thrown when an unsupported char is encountered in legacy format
704
if(self === undefined){
705
throw _b_.TypeError.$factory(
706
"not enough arguments for format string")
733
throw _b_.ValueError.$factory(
734
"unsupported format character '" + invalid_char +
735
"' (0x" + invalid_char.charCodeAt(0).toString(16) +
736
") at index " + newpos)
737
}else if(err.name === "NotANumber"){
738
var try_char = s[newpos],
739
cls = self.__class__
740
if(!cls){
741
if(typeof(self) === "string"){
742
cls = "str"
743
}else{
749
throw _b_.TypeError.$factory("%" + try_char +
750
" format: a number is required, not " + cls)
751
}else{
783
}while(pos < length)
784
785
if(argpos !== null){
786
if(args.length > argpos){
787
throw _b_.TypeError.$factory(
788
"not enough arguments for format string")
789
}else if(args.length < argpos){
790
throw _b_.TypeError.$factory(
791
"not all arguments converted during string formatting")
793
}else if(nbph == 0){
794
throw _b_.TypeError.$factory(
795
"not all arguments converted during string formatting")
803
var $ = $B.args("__mul__", 2, {self: null, other: null},
804
["self", "other"], arguments, {}, null, null)
805
if(! isinstance($.other, _b_.int)){throw _b_.TypeError.$factory(
806
"Can't multiply sequence by non-int of type '" +
807
$B.get_class($.other).__name__ + "'")}
808
var $res = ""
809
for(var i = 0; i< $.other; i++){$res += $.self.valueOf()}
818
res = self.replace(/\\/g, "\\\\")
819
// special cases
820
res = res.replace(new RegExp("\u0007", "g"), "\\x07").
821
replace(new RegExp("\b", "g"), "\\x08").
822
replace(new RegExp("\f", "g"), "\\x0c").
823
replace(new RegExp("\n", "g"), "\\n").
824
replace(new RegExp("\r", "g"), "\\r").
825
replace(new RegExp("\t", "g"), "\\t")
826
if(res.search('"') == -1 && res.search("'") == -1){
827
return "'" + res + "'"
828
}else if(self.search('"') == -1){
829
return '"' + res + '"'
830
}
831
var qesc = new RegExp("'", "g") // to escape single quote
832
res = "'" + res.replace(qesc, "\\'") + "'"
836
str.__setitem__ = function(self, attr, value){
837
throw _b_.TypeError.$factory(
838
"'str' object does not support item assignment")
848
if(typeof other !== "string"){throw _b_.TypeError.$factory(
849
"unorderable types: 'str' > " + $B.get_class(other).__name__ + "()")}
852
$comp_func += "" // source code
853
var $comps = {">": "gt", ">=": "ge", "<": "lt", "<=": "le"}
862
var $notimplemented = function(self, other){
863
throw NotImplementedError.$factory(
864
"OPERATOR not implemented for class str")
867
// Copy static methods from unicode
868
var from_unicode = [
869
"title",
870
"capitalize",
871
"casefold",
872
"islower",
873
"isupper",
874
"istitle",
875
"isspace",
876
"isalpha",
877
"isalnum",
878
"isdecimal",
879
"isdigit",
880
"isnumeric",
881
"isidentifier",
882
"isprintable",
883
"lower",
884
"swapcase",
885
"upper"
886
]
892
str.center = function(){
893
var $ = $B.args("center", 3, {self: null, width: null, fillchar: null},
894
["self", "width", "fillchar"],
895
arguments, {fillchar:" "}, null, null),
896
self = $.self
908
var $ = $B.args("count", 4, {self:null, sub:null, start:null, stop:null},
909
["self", "sub", "start", "stop"], arguments, {start:null, stop:null},
911
if(!(typeof $.sub == "string")){throw _b_.TypeError.$factory(
912
"Can't convert '" + $B.get_class($.sub).__name__ +
913
"' object to str implicitly")}
917
if($.stop !== null){_slice = _b_.slice.$factory($.start, $.stop)}
918
else{_slice = _b_.slice.$factory($.start, $.self.length)}
923
if($.sub.length == 0){
924
if($.start == $.self.length){return 1}
925
else if(substr.length == 0){return 0}
926
return substr.length + 1
928
var n = 0,
929
pos = 0
930
while(pos < substr.length){
931
pos = substr.indexOf($.sub, pos)
932
if(pos >= 0){n++; pos += $.sub.length}
933
else{break}
945
if(("a" <= char && char <= "m") || ("A" <= char && char <= "M")){
946
res += String.fromCharCode(String.charCodeAt(char) + 13)
947
}else if(("m" < char && char <= "z") ||
948
("M" < char && char <= "Z")){
949
res += String.fromCharCode(String.charCodeAt(char) - 13)
958
// Return True if the string ends with the specified suffix, otherwise
959
// return False. suffix can also be a tuple of suffixes to look for.
960
// With optional start, test beginning at that position. With optional
964
["self", "suffix", "start", "end"],
965
arguments, {start: 0, end: null}, null, null)
972
var s = $.self.substring($.start, $.end)
973
for(var i = 0, len = suffixes.length; i < len; i++){
977
if(suffix.length <= s.length &&
978
s.substr(s.length - suffix.length) == suffix){return true}
984
var $ = $B.args("expandtabs", 2, {self: null, tabsize: null},
985
["self", "tabsize"], arguments, {tabsize: 8}, null, null)
986
var s = $B.$GetInt($.tabsize),
987
col = 0,
988
pos = 0,
989
res = ""
990
if(s == 1){return self.replace(/\t/g," ")}
991
while(pos < self.length){
999
res += car
1000
col = 0
1001
break
1002
default:
1003
res += car
1004
col++
1005
break
1006
}
1007
pos++
1008
}
1014
// Return the lowest index in the string where substring sub is found,
1015
// such that sub is contained in the slice s[start:end]. Optional
1016
// arguments start and end are interpreted as in slice notation.
1019
{self: null, sub: null, start: null, end: null},
1020
["self", "sub", "start", "end"],
1021
arguments, {start: 0, end: null}, null, null)
1025
if(!isinstance($.start, _b_.int)||!isinstance($.end, _b_.int)){
1026
throw _b_.TypeError.$factory("slice indices must be " +
1027
"integers or None or have an __index__ method")}
1028
var s = $.self.substring($.start, $.end)
1030
if($.sub.length == 0 && $.start == $.self.length){return $.self.length}
1031
if(s.length + $.sub.length == 0){return -1}
1033
var last_search = s.length - $.sub.length
1034
for(var i = 0; i <= last_search; i++){
1035
if(s.substr(i, $.sub.length) == $.sub){return $.start + i}
1046
// a.x[z]!r:...
1047
// the object has attributes :
1048
// - name : "a"
1049
// - name_ext : [".x", "[z]"]
1050
// - conv : r
1051
// - spec : rest of string after :
1059
// No : in the string : it only contains a name
1060
name = fmt_string
1061
}else{
1062
// name is before the first ":"
1063
// spec (the format specification) is after
1064
name = elts[0]
1068
var elts = name.split("!")
1069
if(elts.length > 1){
1070
name = elts[0]
1071
conv = elts[1] // conversion flag
1075
// "name' may be a subscription or attribute
1076
// Put these "extensions" in the list "name_ext"
1077
function name_repl(match){
1078
name_ext.push(match)
1080
}
1081
var name_ext_re = /\.[_a-zA-Z][_a-zA-Z0-9]*|\[[_a-zA-Z][_a-zA-Z0-9]*\]|\[[0-9]+\]/g
1082
name = name.replace(name_ext_re, name_repl)
1083
}
1090
// Parse self to detect formatting instructions
1091
// Create a list "parts" made of sections of the string :
1092
// - elements of even rank are literal text
1093
// - elements of odd rank are "format objects", built from the
1094
// format strings in self (of the form {...})
1105
text += "{"
1106
pos += 2
1107
}else if(car == "}" && self.charAt(pos + 1) == "}"){
1114
// Store current literal text
1115
parts.push(text)
1116
1117
// Search the end of the format string, ie the } closing the
1118
// opening {. Since the string can contain other pairs {} for
1119
// nested formatting, an integer nb is incremented for each { and
1120
// decremented for each } ; the end of the format string is
1121
// reached when nb == 0
1122
var end = pos + 1,
1123
nb = 1
1124
while(end < _len){
1125
if(self.charAt(end) == "{"){nb++; end++}
1126
else if(self.charAt(end) == "}"){
1127
nb--; end++
1128
if(nb == 0){
1133
var fmt_obj = $B.parse_format(fmt_string)
1134
fmt_obj.raw_name = fmt_obj.name
1135
fmt_obj.raw_spec = fmt_obj.spec
1170
return parts
1171
}
1172
1173
str.format = function(self) {
1174
var $ = $B.args("format", 1, {self: null}, ["self"],
1175
arguments, {}, "$args", "$kw")
1176
1177
var parts = $B.split_format($.self)
1178
1189
1190
if(fmt.spec !== undefined){
1191
// "spec" may contain "nested replacement fields"
1192
// In this case, evaluate them using the positional
1193
// or keyword arguments passed to format()
1194
function replace_nested(name, key){
1195
if(/\d+/.exec(key)){
1196
// If key is numeric, search in positional
1197
// arguments
1198
return _b_.tuple.__getitem__($.$args,
1199
parseInt(key))
1200
}else{
1201
// Else try in keyword arguments
1202
return _b_.dict.__getitem__($.$kw, key)
1203
}
1204
}
1205
fmt.spec = fmt.spec.replace(/\{(.*?)\}/g,
1206
replace_nested)
1207
}
1209
// Numerical reference : use positional arguments
1210
var pos = parseInt(fmt.name),
1220
// Attribute
1221
value = _b_.getattr(value, ext.substr(1))
1222
}else{
1223
// Subscription
1226
if(key.charAt(0).search(/\d/) > -1){key = parseInt(key)}
1227
value = _b_.getattr(value, "__getitem__")(key)
1231
// If the conversion flag is set, first call a function to convert
1232
// the value
1233
if(fmt.conv == "a"){value = _b_.ascii(value)}
1234
else if(fmt.conv == "r"){value = _b_.repr(value)}
1235
else if(fmt.conv == "s"){value = _b_.str.$factory(value)}
1249
throw NotImplementedError.$factory(
1250
"function format_map not implemented yet")
1270
if(! isinstance(obj2, str)){throw _b_.TypeError.$factory(
1271
"sequence item " + count + ": expected str instance, " +
1272
$B.get_class(obj2).__name__ + " found")}
1285
var $ = $B.args("ljust", 3, {self: null, width: null, fillchar:null},
1286
["self", "width", "fillchar"],
1287
arguments, {fillchar: " "}, null, null)
1294
var $ = $B.args("lstrip", 2, {self: null, chars: null}, ["self", "chars"],
1295
arguments, {chars:_b_.None}, null, null)
1296
if($.chars === _b_.None){return $.self.trimLeft()}
1297
for(var i = 0; i < $.self.length; i++){
1298
if($.chars.indexOf($.self.charAt(i)) === -1){
1299
return $.self.substring(i)
1307
var $ = $B.args("maketrans", 3, {x: null, y: null, z: null},
1308
["x", "y", "z"], arguments, {y: null, z: null}, null, null)
1313
// If there is only one argument, it must be a dictionary mapping
1314
// Unicode ordinals (integers) or characters (strings of length 1) to
1315
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1317
if(! _b_.isinstance($.x, _b_.dict)){
1318
throw _b_.TypeError.$factory(
1319
"maketrans only argument must be a dict")
1322
for(var i = 0, len = items.length; i < len; i++){
1323
var k = items[i][0],
1324
v = items[i][1]
1325
if(! _b_.isinstance(k, _b_.int)){
1326
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1327
k = _b_.ord(k)
1328
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1331
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1332
throw _b_.TypeError.$factory("dictionary value " + v +
1340
// and in the resulting dictionary, each character in x will be mapped
1341
// to the character at the same position in y
1344
}else if($.x.length !== $.y.length){
1345
throw _b_.TypeError.$factory(
1346
"maketrans arguments must be strings or same length")
1352
if(! _b_.isinstance($.z, _b_.str)){
1353
throw _b_.TypeError.$factory(
1354
"maketrans third argument must be a string")
1360
for(var i = 0, len = $.x.length; i < len; i++){
1361
_t.$numeric_dict[_b_.ord($.x.charAt(i))] =
1363
}
1364
for(var k in toNone){
1365
_t.$numeric_dict[k] = _b_.None
1366
}
1367
return _t
1368
}
1369
}
1373
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1374
arguments, {}, null, null)
1379
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1380
$.self.substring(i + $.sep.length)])
1381
}
1382
1383
function $re_escape(str){
1384
var specials = "[.*+?|()$^"
1385
for(var i = 0, len = specials.length; i < len; i++){
1386
var re = new RegExp("\\"+specials.charAt(i), "g")
1387
str = str.replace(re, "\\"+specials.charAt(i))
1388
}
1389
return str
1396
var $ = $B.args("replace", 4,
1397
{self: null, old: null, $$new: null, count: null},
1398
["self", "old", "$$new", "count"],
1399
arguments, {count: -1}, null, null),
1400
count = $.count,
1401
self = $.self,
1402
old = $.old,
1403
_new = $.$$new
1410
"' object cannot be interpreted as an integer")
1411
}else if(isinstance(count, _b_.float)){
1412
throw _b_.TypeError.$factory("integer argument expected, got float")
1413
}
1414
if(count == 0){return self}
1415
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1416
if(old == ""){
1417
if(_new == ""){return self}
1418
if(self == ""){return _new}
1419
var elts = self.split("")
1420
if(count > -1 && elts.length >= count){
1421
var rest = elts.slice(count).join("")
1422
return _new + elts.slice(0, count).join(_new) + rest
1423
}else{return _new + elts.join(_new) + _new}
1438
if(count < 0){count = res.length}
1439
while(count > 0){
1440
pos = res.indexOf(old, pos)
1441
if(pos < 0){break}
1442
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1443
pos = pos + _new.length
1444
count--
1450
// Return the highest index in the string where substring sub is found,
1451
// such that sub is contained within s[start:end]. Optional arguments
1454
{self: null, sub: null, start: null, end: null},
1455
["self", "sub", "start", "end"],
1456
arguments, {start: 0, end: null}, null, null)
1468
for(var i = $.end - sublen; i >= $.start; i--){
1469
if($.self.substr(i, sublen) == $.sub){return i}
1476
var res = str.rfind.apply(null, arguments)
1477
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1482
var $ = $B.args("rjust",3,
1483
{self: null, width: null, fillchar: null},
1484
["self", "width", "fillchar"],
1485
arguments, {fillchar: " "}, null, null)
1493
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1494
arguments, {}, null, null)
1498
var items = str.partition(self, sep).reverse()
1499
for(var i = 0; i < items.length; i++){
1500
items[i] = items[i].split("").reverse().join("")
1506
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1507
["self", "sep", "maxsplit"], arguments,
1508
{sep: _b_.None, maxsplit: -1}, null, null),
1509
sep = $.sep
1512
var rev_str = reverse($.self),
1513
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1524
str.rstrip = function(self, x){
1525
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1526
arguments, {chars: _b_.None}, null, null)
1527
if($.chars === _b_.None){return $.self.trimRight()}
1529
if($.chars.indexOf($.self.charAt(j)) == -1){
1530
return $.self.substring(0, j + 1)
1537
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1538
["self", "sep", "maxsplit"], arguments,
1539
{sep: _b_.None, maxsplit: -1}, null, null),
1540
sep = $.sep,
1541
maxsplit = $.maxsplit,
1542
self = $.self,
1543
pos = 0
1544
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1545
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1546
if(sep === _b_.None){
1548
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1549
if(pos === self.length - 1){return [self]}
1550
var name = ""
1552
if(self.charAt(pos).search(/\s/) == -1){
1553
if(name == ""){name = self.charAt(pos)}
1554
else{name += self.charAt(pos)}
1574
var res = [],
1575
s = "",
1576
seplen = sep.length
1577
if(maxsplit == 0){return [self]}
1578
while(pos < self.length){
1579
if(self.substr(pos, seplen) == sep){
1599
["self", "keepends"], arguments, {keepends: false}, null, null)
1600
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1601
throw _b_.TypeError.$factory("integer argument expected, got " +
1608
start = pos,
1609
pos = 0,
1610
self = $.self
1611
while(pos < self.length){
1612
if(self.substr(pos, 2) == "\r\n"){
1613
res.push(self.substring(start, pos + 2))
1614
start = pos + 2
1616
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1617
res.push(self.substring(start, pos + 1))
1618
start = pos + 1
1619
pos = start
1620
}else{pos++}
1621
}
1622
var rest = self.substr(start)
1623
if(rest){res.push(rest)}
1624
return res
1625
}else{
1632
// Return True if string starts with the prefix, otherwise return False.
1633
// prefix can also be a tuple of prefixes to look for. With optional
1634
// start, test string beginning at that position. With optional end,
1636
var $ = $B.args("startswith", 4,
1637
{self: null, prefix: null, start: null, end: null},
1638
["self", "prefix", "start", "end"],
1639
arguments, {start: 0, end: null}, null, null)
1646
var s = $.self.substring($.start, $.end)
1647
for(var i = 0, len = prefixes.length; i < len; i++){
1658
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1659
arguments, {chars: _b_.None}, null, null)
1660
if($.chars === _b_.None){return $.self.trim()}
1661
for(var i = 0; i < $.self.length; i++){
1662
if($.chars.indexOf($.self.charAt(i)) == -1){
1663
break
1666
for(var j = $.self.length - 1; j >= i; j--){
1667
if($.chars.indexOf($.self.charAt(j)) == -1){
1668
break
1676
getitem = $B.$getattr(table, "__getitem__")
1677
for(var i = 0, len = self.length; i < len; i++){
1678
try{
1679
var repl = getitem(self.charCodeAt(i))
1680
if(repl !== _b_.None){
1681
res.push(repl)
1682
}
1683
}catch(err){
1684
res.push(self.charAt(i))
1685
}
1692
["self", "width"], arguments, {}, null, null)
1693
if($.width <= self.length){return self}
1695
case "+":
1696
case "-":
1697
return self.charAt(0) +
1698
"0".repeat($.width - self.length) + self.substr(1)
1707
case "string":
1708
return arg
1709
case "number":
1710
if(isFinite(arg)){return arg.toString()}
1716
// class or its subclasses, but the attribute __str__ of the
1717
// class metaclass (usually "type") or its subclasses (usually
1718
// "object")
1719
// The metaclass is the attribute __class__ of the class dictionary
1723
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1724
encoding !== undefined){
1725
// str(bytes, encoding, errors) is equal to
1726
// bytes.decode(encoding, errors)
1727
return _b_.bytes.decode(arg, encoding || "utf-8",
1728
errors || "strict")
1729
}
1730
var f = $B.$getattr(arg, "__str__", null)
1731
if(f === null ||
1732
// if not better than object.__str__, try __repr__
1733
(arg.__class__ && arg.__class__ !== _b_.object &&
1734
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1735
var f = $B.$getattr(arg, "__repr__")
1736
}
1741
if($B.debug > 1){console.log(err)}
1742
console.log("Warning - no method __str__ or __repr__, " +
1743
"default to toString", arg)
1744
return arg.toString()
1750
if(cls === undefined){
1751
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1772
var args = [],
1773
pos = 0
1774
if(arguments.length > 0){
1775
var args = [arguments[0].valueOf()],
1776
pos = 1
1777
for(var i = 1, len = arguments.length; i < len; i++){
1778
args[pos++] = arguments[i]
1794
// Function to parse the 2nd argument of format()
1795
$B.parse_format_spec = function(spec){
1798
var pos = 0,
1799
aligns = "<>=^",
1800
digits = "0123456789",
1801
types = "bcdeEfFgGnosxX%",
1803
if(align_pos != -1){
1804
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1805
// If the second char is also an alignment specifier, the
1806
// first char is the fill value
1807
this.fill = spec.charAt(0)
1808
this.align = spec.charAt(1)
1809
pos = 2
1810
}else{
1811
// The first character defines alignment : fill defaults to ' '
1826
if(car == "+" || car == "-" || car == " "){
1827
this.sign = car
1828
pos++
1829
car = spec.charAt(pos)
1831
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1832
if(car == "0"){
1839
while(car && digits.indexOf(car) > -1){
1840
if(this.width === undefined){this.width = car}
1841
else{this.width += car}
1842
pos++
1843
car = spec.charAt(pos)
1846
if(this.width === undefined && car == "{"){
1847
// Width is determined by a parameter
1848
var end_param_pos = spec.substr(pos).search("}")
1849
this.width = spec.substring(pos, end_param_pos)
1850
console.log("width", "[" + this.width + "]")
1851
pos += end_param_pos + 1
1852
}
1853
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1854
if(car == "."){
1855
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1856
throw _b_.ValueError.$factory(
1857
"Missing precision in format spec")
1859
this.precision = spec.charAt(pos + 1)
1860
pos += 2
1861
car = spec.charAt(pos)
1862
while(car && digits.indexOf(car) > -1){
1869
if(car && types.indexOf(car) > -1){
1870
this.type = car
1871
pos++
1872
car = spec.charAt(pos)
1873
}
1874
if(pos !== spec.length){
1879
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1880
(this.align || "") +
1881
(this.sign || "") +
1882
(this.alternate ? "#" : "") +
1883
(this.sign_aware ? "0" : "") +
1884
(this.width || "") +
1885
(this.comma ? "," : "") +
1886
(this.precision ? "." + this.precision : "") +
1887
(this.type || "")
1892
if(fmt.width && s.length < fmt.width){
1893
var fill = fmt.fill || " ",
1894
align = fmt.align || "<",
1895
missing = fmt.width - s.length
1897
case "<":
1898
return s + fill.repeat(missing)
1899
case ">":
1900
return fill.repeat(missing) + s
1901
case "=":
1902
if("+-".indexOf(s.charAt(0)) > -1){
1903
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1907
case "^":
1908
var left = parseInt(missing / 2)
1909
return fill.repeat(left) + s + fill.repeat(missing - left)
1922
$B.parse_fstring = function(string){
1923
// Parse a f-string
1924
var elts = [],
1925
pos = 0,
1949
}else{
1950
throw Error(" f-string: single '}' is not allowed")
1951
}
1952
}else{
1974
current += car
1975
i += 2
1976
}else{
1977
throw Error(" f-string: single '}' is not allowed")
1978
}
1979
}else{
1980
current += car
1981
i++
1982
}
1983
}
1985
}else{
1986
// End of expression is the } matching the opening {
1987
// There may be nested braces
1988
var i = pos,
1989
nb_braces = 1,
2011
// backslash is not allowed in expressions
2012
throw Error("f-string expression part cannot include a" +
2013
" backslash")
2020
throw Error("f-string: invalid conversion character:" +
2021
" expected 's', 'r', or 'a'")
2022
}else{
2036
if(string.substr(i, 3) == '"""'){
2037
var end = string.indexOf('"""', i + 3)
2038
if(end == -1){
2039
throw Error("f-string: unterminated string")
2040
}else{
2041
var trs = string.substring(i, end + 3)
2042
trs = trs.replace("\n", "\\n\\")
2047
var end = string.indexOf('"', i + 1)
2048
if(end == -1){
2049
throw Error("f-string: unterminated string")
2050
}else{
2051
current.expression += string.substring(i, end + 1)
2052
i = end + 1