@@ -53,8 +53,8 @@ var PROCESS;
53
53
EventEmitter . prototype . emit = function ( type ) {
54
54
// If there is no 'error' event listener then throw.
55
55
if ( type === 'error' ) {
56
- if ( ! this . _events || ! this . _events . error ||
57
- ( isArray ( this . _events . error ) && ! this . _events . error . length ) )
56
+ if ( ! this . _events || ! this . _events . everror ||
57
+ ( isArray ( this . _events . everror ) && ! this . _events . everror . length ) )
58
58
{
59
59
if ( this . domain ) {
60
60
var er = arguments [ 1 ] ;
@@ -75,7 +75,8 @@ EventEmitter.prototype.emit = function(type) {
75
75
}
76
76
77
77
if ( ! this . _events ) return false ;
78
- var handler = this . _events [ type ] ;
78
+ var evtype = 'ev' + type ;
79
+ var handler = this . _events [ evtype ] ;
79
80
if ( ! handler ) return false ;
80
81
81
82
if ( typeof handler == 'function' ) {
@@ -142,36 +143,37 @@ EventEmitter.prototype.addListener = function(type, listener) {
142
143
143
144
// To avoid recursion in the case that type == "newListener"! Before
144
145
// adding it to the listeners, first emit "newListener".
145
- if ( this . _events . newListener ) {
146
+ if ( this . _events . evnewListener ) {
146
147
this . emit ( 'newListener' , type , typeof listener . listener === 'function' ?
147
148
listener . listener : listener ) ;
148
149
}
149
150
150
- if ( ! this . _events [ type ] ) {
151
+ var evtype = 'ev' + type ;
152
+ if ( ! this . _events [ evtype ] ) {
151
153
// Optimize the case of one listener. Don't need the extra array object.
152
- this . _events [ type ] = listener ;
153
- } else if ( isArray ( this . _events [ type ] ) ) {
154
+ this . _events [ evtype ] = listener ;
155
+ } else if ( isArray ( this . _events [ evtype ] ) ) {
154
156
155
157
// If we've already got an array, just append.
156
- this . _events [ type ] . push ( listener ) ;
158
+ this . _events [ evtype ] . push ( listener ) ;
157
159
158
160
} else {
159
161
// Adding the second element, need to change to array.
160
- this . _events [ type ] = [ this . _events [ type ] , listener ] ;
162
+ this . _events [ evtype ] = [ this . _events [ evtype ] , listener ] ;
161
163
162
164
}
163
165
164
166
// Check for listener leak
165
- if ( isArray ( this . _events [ type ] ) && ! this . _events [ type ] . warned ) {
167
+ if ( isArray ( this . _events [ evtype ] ) && ! this . _events [ evtype ] . warned ) {
166
168
var m ;
167
169
m = this . _maxListeners ;
168
170
169
- if ( m && m > 0 && this . _events [ type ] . length > m ) {
170
- this . _events [ type ] . warned = true ;
171
+ if ( m && m > 0 && this . _events [ evtype ] . length > m ) {
172
+ this . _events [ evtype ] . warned = true ;
171
173
console . error ( '(node) warning: possible EventEmitter memory ' +
172
174
'leak detected. %d listeners added. ' +
173
175
'Use emitter.setMaxListeners() to increase limit.' ,
174
- this . _events [ type ] . length ) ;
176
+ this . _events [ evtype ] . length ) ;
175
177
console . trace ( ) ;
176
178
}
177
179
}
@@ -204,10 +206,11 @@ EventEmitter.prototype.removeListener = function(type, listener) {
204
206
throw new Error ( 'removeListener only takes instances of Function' ) ;
205
207
}
206
208
207
- // does not use listeners(), so no side effect of creating _events[type]
208
- if ( ! this . _events || ! this . _events [ type ] ) return this ;
209
+ var evtype = 'ev' + type ;
210
+ // does not use listeners(), so no side effect of creating _events[evtype]
211
+ if ( ! this . _events || ! this . _events [ evtype ] ) return this ;
209
212
210
- var list = this . _events [ type ] ;
213
+ var list = this . _events [ evtype ] ;
211
214
212
215
if ( isArray ( list ) ) {
213
216
var position = - 1 ;
@@ -223,17 +226,17 @@ EventEmitter.prototype.removeListener = function(type, listener) {
223
226
if ( position < 0 ) return this ;
224
227
list . splice ( position , 1 ) ;
225
228
if ( list . length == 0 )
226
- this . _events [ type ] = null ;
229
+ this . _events [ evtype ] = null ;
227
230
228
- if ( this . _events . removeListener ) {
231
+ if ( this . _events . evremoveListener ) {
229
232
this . emit ( 'removeListener' , type , listener ) ;
230
233
}
231
234
} else if ( list === listener ||
232
235
( list . listener && list . listener === listener ) )
233
236
{
234
- this . _events [ type ] = null ;
237
+ this . _events [ evtype ] = null ;
235
238
236
- if ( this . _events . removeListener ) {
239
+ if ( this . _events . evremoveListener ) {
237
240
this . emit ( 'removeListener' , type , listener ) ;
238
241
}
239
242
}
@@ -245,27 +248,28 @@ EventEmitter.prototype.removeAllListeners = function(type) {
245
248
if ( ! this . _events ) return this ;
246
249
247
250
// fast path
248
- if ( ! this . _events . removeListener ) {
251
+ if ( ! this . _events . evremoveListener ) {
249
252
if ( arguments . length === 0 ) {
250
253
this . _events = { } ;
251
- } else if ( type && this . _events && this . _events [ type ] ) {
252
- this . _events [ type ] = null ;
254
+ } else if ( type && this . _events && this . _events [ 'ev' + type ] ) {
255
+ this . _events [ 'ev' + type ] = null ;
253
256
}
254
257
return this ;
255
258
}
256
259
257
260
// slow(ish) path, emit 'removeListener' events for all removals
258
261
if ( arguments . length === 0 ) {
259
262
for ( var key in this . _events ) {
260
- if ( key === 'removeListener ' ) continue ;
261
- this . removeAllListeners ( key ) ;
263
+ if ( key === 'evremoveListener ' ) continue ;
264
+ this . removeAllListeners ( key . slice ( 2 ) ) ;
262
265
}
263
266
this . removeAllListeners ( 'removeListener' ) ;
264
267
this . _events = { } ;
265
268
return this ;
266
269
}
267
270
268
- var listeners = this . _events [ type ] ;
271
+ var evtype = 'ev' + type ;
272
+ var listeners = this . _events [ evtype ] ;
269
273
if ( isArray ( listeners ) ) {
270
274
while ( listeners . length ) {
271
275
// LIFO order
@@ -274,15 +278,16 @@ EventEmitter.prototype.removeAllListeners = function(type) {
274
278
} else if ( listeners ) {
275
279
this . removeListener ( type , listeners ) ;
276
280
}
277
- this . _events [ type ] = null ;
281
+ this . _events [ evtype ] = null ;
278
282
279
283
return this ;
280
284
} ;
281
285
282
286
EventEmitter . prototype . listeners = function ( type ) {
283
- if ( ! this . _events || ! this . _events [ type ] ) return [ ] ;
284
- if ( ! isArray ( this . _events [ type ] ) ) {
285
- return [ this . _events [ type ] ] ;
287
+ var evtype = 'ev' + type ;
288
+ if ( ! this . _events || ! this . _events [ evtype ] ) return [ ] ;
289
+ if ( ! isArray ( this . _events [ evtype ] ) ) {
290
+ return [ this . _events [ evtype ] ] ;
286
291
}
287
- return this . _events [ type ] . slice ( 0 ) ;
292
+ return this . _events [ evtype ] . slice ( 0 ) ;
288
293
} ;
0 commit comments