whole_func_string: function(args) {
              // NOTE: this code is deliberately as few expressions (and no function calls)
              // as possible so that a debugger can skip over this noise with the minimum number
              // of steps. Basically, just hit Step Into until you are where you really wanted
              // to be.
              var method,
                  superMethod = (method = this.callParent.caller) && (method.$previous ||
                          ((method = method.$owner ? method : method.caller) &&
                                  method.$owner.superclass[method.$name]));
  
              //<debug error>
              if (!superMethod) {
                  method = this.callParent.caller;
                  var parentClass, methodName;
  
                  if (!method.$owner) {
                      if (!method.caller) {
                          throw new Error("Attempting to call a protected method from the public scope, which is not allowed");
                      }
  
                      method = method.caller;
                  }
  
                  parentClass = method.$owner.superclass;
                  methodName = method.$name;
  
                  if (!(methodName in parentClass)) {
                      throw new Error("this.callParent() was called but there's no such method (" + methodName +
                                  ") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")");
                  }
              }
              //</debug>
  
              return superMethod.apply(this, args || noArgs);
          }
func_code_string: function(args) {
              // NOTE: this code is deliberately as few expressions (and no function calls)
              // as possible so that a debugger can skip over this noise with the minimum number
              // of steps. Basically, just hit Step Into until you are where you really wanted
              // to be.
              var method,
                  superMethod = (method = this.callParent.caller) && (method.$previous ||
                          ((method = method.$owner ? method : method.caller) &&
                                  method.$owner.superclass[method.$name]));
  
              //<debug error>
              if (!superMethod) {
                  method = this.callParent.caller;
                  var parentClass, methodName;
  
                  if (!method.$owner) {
                      if (!method.caller) {
                          throw new Error("Attempting to call a protected method from the public scope, which is not allowed");
                      }
  
                      method = method.caller;
                  }
  
                  parentClass = method.$owner.superclass;
                  methodName = method.$name;
  
                  if (!(methodName in parentClass)) {
                      throw new Error("this.callParent() was called but there's no such method (" + methodName +
                                  ") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")");
                  }
              }
              //</debug>
  
              return superMethod.apply(this, args || noArgs);
          }
func_documentation_string: Call the "parent" method of the current method. That is the method previously
  overridden by derivation or by an override (see {@link Ext#define}).
  
  Ext.define('My.Base', {
  constructor: function (x) {
  this.x = x;
  },
  
  statics: {
  method: function (x) {
  return x;
  }
  }
  });
  
  Ext.define('My.Derived', {
  extend: 'My.Base',
  
  constructor: function () {
  this.callParent([21]);
  }
  });
  
  var obj = new My.Derived();
  
  alert(obj.x);  // alerts 21
  
  This can be used with an override as follows:
  
  Ext.define('My.DerivedOverride', {
  override: 'My.Derived',
  
  constructor: function (x) {
  this.callParent([x*2]); // calls original My.Derived constructor
  }
  });
  
  var obj = new My.Derived();
  
  alert(obj.x);  // now alerts 42
  
  This also works with static methods.
  
  Ext.define('My.Derived2', {
  extend: 'My.Base',
  
  statics: {
  method: function (x) {
  return this.callParent([x*2]); // calls My.Base.method
  }
  }
  });
  
  alert(My.Base.method(10);     // alerts 10
  alert(My.Derived2.method(10); // alerts 20
  
  Lastly, it also works with overridden static methods.
  
  Ext.define('My.Derived2Override', {
  override: 'My.Derived2',
  
  statics: {
  method: function (x) {
  return this.callParent([x*2]); // calls My.Derived2.method
  }
  }
  });
  
  alert(My.Derived2.method(10); // now alerts 40
  
  To override a method and replace it and also call the superclass method, use
  {@link #callSuper}. This is often done to patch a method to fix a bug.
  
  @protected
  @param {Array/Arguments} args The arguments, either an array or the `arguments` object
  from the current method, for example: `this.callParent(arguments)`
  @return {Object} Returns the result of calling the parent method