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
Mar 19, 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
2072 lines (1901 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)
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)
1315
// If there is only one argument, it must be a dictionary mapping
1316
// Unicode ordinals (integers) or characters (strings of length 1) to
1317
// Unicode ordinals, strings (of arbitrary lengths) or None. Character
1319
if(! _b_.isinstance($.x, _b_.dict)){
1320
throw _b_.TypeError.$factory(
1321
"maketrans only argument must be a dict")
1324
for(var i = 0, len = items.length; i < len; i++){
1325
var k = items[i][0],
1326
v = items[i][1]
1327
if(! _b_.isinstance(k, _b_.int)){
1328
if(_b_.isinstance(k, _b_.str) && k.length == 1){
1329
k = _b_.ord(k)
1330
}else{throw _b_.TypeError.$factory("dictionary key " + k +
1333
if(v !== _b_.None && ! _b_.isinstance(v, [_b_.int, _b_.str])){
1334
throw _b_.TypeError.$factory("dictionary value " + v +
1342
// and in the resulting dictionary, each character in x will be mapped
1343
// to the character at the same position in y
1346
}else if($.x.length !== $.y.length){
1347
throw _b_.TypeError.$factory(
1348
"maketrans arguments must be strings or same length")
1354
if(! _b_.isinstance($.z, _b_.str)){
1355
throw _b_.TypeError.$factory(
1356
"maketrans third argument must be a string")
1362
for(var i = 0, len = $.x.length; i < len; i++){
1363
_t.$numeric_dict[_b_.ord($.x.charAt(i))] =
1364
_b_.ord($.y.charAt(i))
1365
}
1366
for(var k in toNone){
1367
_t.$numeric_dict[k] = _b_.None
1368
}
1369
return _t
1370
}
1371
}
1375
var $ = $B.args("partition", 2, {self: null, sep: null}, ["self", "sep"],
1376
arguments, {}, null, null)
1381
return _b_.tuple.$factory([$.self.substring(0, i), $.sep,
1382
$.self.substring(i + $.sep.length)])
1383
}
1384
1385
function $re_escape(str){
1386
var specials = "[.*+?|()$^"
1387
for(var i = 0, len = specials.length; i < len; i++){
1388
var re = new RegExp("\\"+specials.charAt(i), "g")
1389
str = str.replace(re, "\\"+specials.charAt(i))
1390
}
1391
return str
1398
var $ = $B.args("replace", 4,
1399
{self: null, old: null, $$new: null, count: null},
1400
["self", "old", "$$new", "count"],
1401
arguments, {count: -1}, null, null),
1402
count = $.count,
1403
self = $.self,
1404
old = $.old,
1405
_new = $.$$new
1412
"' object cannot be interpreted as an integer")
1413
}else if(isinstance(count, _b_.float)){
1414
throw _b_.TypeError.$factory("integer argument expected, got float")
1415
}
1416
if(count == 0){return self}
1417
if(count.__class__ == $B.long_int){count = parseInt(count.value)}
1418
if(old == ""){
1419
if(_new == ""){return self}
1420
if(self == ""){return _new}
1421
var elts = self.split("")
1422
if(count > -1 && elts.length >= count){
1423
var rest = elts.slice(count).join("")
1424
return _new + elts.slice(0, count).join(_new) + rest
1425
}else{return _new + elts.join(_new) + _new}
1440
if(count < 0){count = res.length}
1441
while(count > 0){
1442
pos = res.indexOf(old, pos)
1443
if(pos < 0){break}
1444
res = res.substr(0, pos) + _new + res.substr(pos + old.length)
1445
pos = pos + _new.length
1446
count--
1452
// Return the highest index in the string where substring sub is found,
1453
// such that sub is contained within s[start:end]. Optional arguments
1456
{self: null, sub: null, start: null, end: null},
1457
["self", "sub", "start", "end"],
1458
arguments, {start: 0, end: null}, null, null)
1470
for(var i = $.end - sublen; i >= $.start; i--){
1471
if($.self.substr(i, sublen) == $.sub){return i}
1478
var res = str.rfind.apply(null, arguments)
1479
if(res == -1){throw _b_.ValueError.$factory("substring not found")}
1484
var $ = $B.args("rjust",3,
1485
{self: null, width: null, fillchar: null},
1486
["self", "width", "fillchar"],
1487
arguments, {fillchar: " "}, null, null)
1495
var $ = $B.args("rpartition", 2, {self: null, sep: null}, ["self", "sep"],
1496
arguments, {}, null, null)
1500
var items = str.partition(self, sep).reverse()
1501
for(var i = 0; i < items.length; i++){
1502
items[i] = items[i].split("").reverse().join("")
1508
var $ = $B.args("rsplit", 3, {self: null, sep: null, maxsplit: null},
1509
["self", "sep", "maxsplit"], arguments,
1510
{sep: _b_.None, maxsplit: -1}, null, null),
1511
sep = $.sep
1514
var rev_str = reverse($.self),
1515
rev_sep = sep === _b_.None ? sep : reverse($.sep),
1526
str.rstrip = function(self, x){
1527
var $ = $B.args("rstrip", 2, {self: null, chars: null}, ["self", "chars"],
1528
arguments, {chars: _b_.None}, null, null)
1529
if($.chars === _b_.None){return $.self.trimRight()}
1531
if($.chars.indexOf($.self.charAt(j)) == -1){
1532
return $.self.substring(0, j + 1)
1539
var $ = $B.args("split", 3, {self: null, sep: null, maxsplit: null},
1540
["self", "sep", "maxsplit"], arguments,
1541
{sep: _b_.None, maxsplit: -1}, null, null),
1542
sep = $.sep,
1543
maxsplit = $.maxsplit,
1544
self = $.self,
1545
pos = 0
1546
if(maxsplit.__class__ === $B.long_int){maxsplit = parseInt(maxsplit.value)}
1547
if(sep == ""){throw _b_.ValueError.$factory("empty separator")}
1548
if(sep === _b_.None){
1550
while(pos < self.length && self.charAt(pos).search(/\s/) > -1){pos++}
1551
if(pos === self.length - 1){return [self]}
1552
var name = ""
1554
if(self.charAt(pos).search(/\s/) == -1){
1555
if(name == ""){name = self.charAt(pos)}
1556
else{name += self.charAt(pos)}
1576
var res = [],
1577
s = "",
1578
seplen = sep.length
1579
if(maxsplit == 0){return [self]}
1580
while(pos < self.length){
1581
if(self.substr(pos, seplen) == sep){
1601
["self", "keepends"], arguments, {keepends: false}, null, null)
1602
if(! _b_.isinstance($.keepends, [_b_.bool, _b_.int])){
1603
throw _b_.TypeError.$factory("integer argument expected, got " +
1610
start = pos,
1611
pos = 0,
1612
self = $.self
1613
while(pos < self.length){
1614
if(self.substr(pos, 2) == "\r\n"){
1615
res.push(self.substring(start, pos + 2))
1616
start = pos + 2
1618
}else if(self.charAt(pos) == "\r" || self.charAt(pos) == "\n"){
1619
res.push(self.substring(start, pos + 1))
1620
start = pos + 1
1621
pos = start
1622
}else{pos++}
1623
}
1624
var rest = self.substr(start)
1625
if(rest){res.push(rest)}
1626
return res
1627
}else{
1634
// Return True if string starts with the prefix, otherwise return False.
1635
// prefix can also be a tuple of prefixes to look for. With optional
1636
// start, test string beginning at that position. With optional end,
1638
var $ = $B.args("startswith", 4,
1639
{self: null, prefix: null, start: null, end: null},
1640
["self", "prefix", "start", "end"],
1641
arguments, {start: 0, end: null}, null, null)
1648
var s = $.self.substring($.start, $.end)
1649
for(var i = 0, len = prefixes.length; i < len; i++){
1660
var $ = $B.args("strip", 2, {self: null, chars: null}, ["self", "chars"],
1661
arguments, {chars: _b_.None}, null, null)
1662
if($.chars === _b_.None){return $.self.trim()}
1663
for(var i = 0; i < $.self.length; i++){
1664
if($.chars.indexOf($.self.charAt(i)) == -1){
1665
break
1668
for(var j = $.self.length - 1; j >= i; j--){
1669
if($.chars.indexOf($.self.charAt(j)) == -1){
1670
break
1676
str.translate = function(self,table){
1677
var res = [],
1678
pos = 0
1679
if(isinstance(table, _b_.dict)){
1680
for(var i = 0, len = self.length; i < len; i++){
1681
var repl = _b_.dict.get(table,self.charCodeAt(i), -1)
1682
if(repl == -1){res[pos++] = self.charAt(i)}
1683
else if(repl !== None){res[pos++] = _b_.chr(repl)}
1691
["self", "width"], arguments, {}, null, null)
1692
if($.width <= self.length){return self}
1694
case "+":
1695
case "-":
1696
return self.charAt(0) +
1697
"0".repeat($.width - self.length) + self.substr(1)
1706
case "string":
1707
return arg
1708
case "number":
1709
if(isFinite(arg)){return arg.toString()}
1715
// class or its subclasses, but the attribute __str__ of the
1716
// class metaclass (usually "type") or its subclasses (usually
1717
// "object")
1718
// The metaclass is the attribute __class__ of the class dictionary
1722
if(arg.__class__ && arg.__class__ === _b_.bytes &&
1723
encoding !== undefined){
1724
// str(bytes, encoding, errors) is equal to
1725
// bytes.decode(encoding, errors)
1726
return _b_.bytes.decode(arg, encoding || "utf-8",
1727
errors || "strict")
1728
}
1729
var f = $B.$getattr(arg, "__str__", null)
1730
if(f === null ||
1731
// if not better than object.__str__, try __repr__
1732
(arg.__class__ && arg.__class__ !== _b_.object &&
1733
f.$infos && f.$infos.__func__ === _b_.object.__str__)){
1734
var f = $B.$getattr(arg, "__repr__")
1735
}
1740
if($B.debug > 1){console.log(err)}
1741
console.log("Warning - no method __str__ or __repr__, " +
1742
"default to toString", arg)
1743
return arg.toString()
1749
if(cls === undefined){
1750
throw _b_.TypeError.$factory("str.__new__(): not enough arguments")
1771
var args = [],
1772
pos = 0
1773
if(arguments.length > 0){
1774
var args = [arguments[0].valueOf()],
1775
pos = 1
1776
for(var i = 1, len = arguments.length; i < len; i++){
1777
args[pos++] = arguments[i]
1793
// Function to parse the 2nd argument of format()
1794
$B.parse_format_spec = function(spec){
1797
var pos = 0,
1798
aligns = "<>=^",
1799
digits = "0123456789",
1800
types = "bcdeEfFgGnosxX%",
1802
if(align_pos != -1){
1803
if(spec.charAt(1) && aligns.indexOf(spec.charAt(1)) != -1){
1804
// If the second char is also an alignment specifier, the
1805
// first char is the fill value
1806
this.fill = spec.charAt(0)
1807
this.align = spec.charAt(1)
1808
pos = 2
1809
}else{
1810
// The first character defines alignment : fill defaults to ' '
1825
if(car == "+" || car == "-" || car == " "){
1826
this.sign = car
1827
pos++
1828
car = spec.charAt(pos)
1830
if(car == "#"){this.alternate = true; pos++; car = spec.charAt(pos)}
1831
if(car == "0"){
1838
while(car && digits.indexOf(car) > -1){
1839
if(this.width === undefined){this.width = car}
1840
else{this.width += car}
1841
pos++
1842
car = spec.charAt(pos)
1845
if(this.width === undefined && car == "{"){
1846
// Width is determined by a parameter
1847
var end_param_pos = spec.substr(pos).search("}")
1848
this.width = spec.substring(pos, end_param_pos)
1849
console.log("width", "[" + this.width + "]")
1850
pos += end_param_pos + 1
1851
}
1852
if(car == ","){this.comma = true; pos++; car = spec.charAt(pos)}
1853
if(car == "."){
1854
if(digits.indexOf(spec.charAt(pos + 1)) == -1){
1855
throw _b_.ValueError.$factory(
1856
"Missing precision in format spec")
1858
this.precision = spec.charAt(pos + 1)
1859
pos += 2
1860
car = spec.charAt(pos)
1861
while(car && digits.indexOf(car) > -1){
1868
if(car && types.indexOf(car) > -1){
1869
this.type = car
1870
pos++
1871
car = spec.charAt(pos)
1872
}
1873
if(pos !== spec.length){
1878
return (this.fill === undefined ? "" : _b_.str.$factory(this.fill)) +
1879
(this.align || "") +
1880
(this.sign || "") +
1881
(this.alternate ? "#" : "") +
1882
(this.sign_aware ? "0" : "") +
1883
(this.width || "") +
1884
(this.comma ? "," : "") +
1885
(this.precision ? "." + this.precision : "") +
1886
(this.type || "")
1891
if(fmt.width && s.length < fmt.width){
1892
var fill = fmt.fill || " ",
1893
align = fmt.align || "<",
1894
missing = fmt.width - s.length
1896
case "<":
1897
return s + fill.repeat(missing)
1898
case ">":
1899
return fill.repeat(missing) + s
1900
case "=":
1901
if("+-".indexOf(s.charAt(0)) > -1){
1902
return s.charAt(0) + fill.repeat(missing) + s.substr(1)
1906
case "^":
1907
var left = parseInt(missing / 2)
1908
return fill.repeat(left) + s + fill.repeat(missing - left)
1921
$B.parse_fstring = function(string){
1922
// Parse a f-string
1923
var elts = [],
1924
pos = 0,
1948
}else{
1949
throw Error(" f-string: single '}' is not allowed")
1950
}
1951
}else{
1973
current += car
1974
i += 2
1975
}else{
1976
throw Error(" f-string: single '}' is not allowed")
1977
}
1978
}else{
1979
current += car
1980
i++
1981
}
1982
}
1984
}else{
1985
// End of expression is the } matching the opening {
1986
// There may be nested braces
1987
var i = pos,
1988
nb_braces = 1,
2010
// backslash is not allowed in expressions
2011
throw Error("f-string expression part cannot include a" +
2012
" backslash")
2019
throw Error("f-string: invalid conversion character:" +
2020
" expected 's', 'r', or 'a'")
2021
}else{
2035
if(string.substr(i, 3) == '"""'){
2036
var end = string.indexOf('"""', i + 3)
2037
if(end == -1){
2038
throw Error("f-string: unterminated string")
2039
}else{
2040
var trs = string.substring(i, end + 3)
2041
trs = trs.replace("\n", "\\n\\")
2046
var end = string.indexOf('"', i + 1)
2047
if(end == -1){
2048
throw Error("f-string: unterminated string")
2049
}else{
2050
current.expression += string.substring(i, end + 1)
2051
i = end + 1