Clear all previous variables
357047
public function clearAll()
    {
        $this->commandName = null;
        $this->configs = array();
        $this->commandArguments = array();
        $this->commandSubject = null;
        $this->commandSubject2 = null;
        $this->path = null;
        $this->binaryVersion = null;
    }
1070305
private static function RemoveUndefinedVars(){
            $oThis = self::CreateInstanceIfNotExists();
            $iOffset = 0;

            while(preg_match('/{\$(.*?)}/i', $oThis->sBuffer, $aMatches, PREG_OFFSET_CAPTURE, $iOffset)){
                $oThis->sBuffer = str_replace($aMatches[0][0], "false", $oThis->sBuffer);
                $iOffset = $aMatches[0][1]+strlen($aMatches[0][0]);
            }
        }
101510
def _clean_salt_variables(params, variable_prefix="__"):
    '''
    
    '''
    list(list(map(params.pop, [k for k in params if k.startswith(variable_prefix)])))
    return params
109753
public void clearHistory()
	{
		int channels = inArray.length;
		for (int c=0; c<channels; c++)
		{
			for (int i=0; i<HISTORYSIZE; i++)
			{
				inArray[c][i] = outArray[c][i] = 0f;
			}
		}
	}
720424
private function resetVars()
    {
        $this->response = $this->calls = [];
        $this->hasCalls = $this->isBatchCall = false;
    }
519134
function clear() {
        var that = this;
        var state = getInternalState(that);
        var data = state.index;
        var entry = state.first;
        while (entry) {
          entry.removed = true;
          if (entry.previous) entry.previous = entry.previous.next = undefined;
          delete data[entry.index];
          entry = entry.next;
        }
        state.first = state.last = undefined;
        if (DESCRIPTORS) state.size = 0;
        else that.size = 0;
      }
1176775
function reset() {
        foreach ($this->vars as $key=>$val) {
            unset($this->env[$key]);
        }
        $this->vars = array();
    }
653412
def clear(self):
        ""
        if isinstance(self.data, np.ndarray):
            data = self.data[:, :0]
        elif util.pd and isinstance(self.data, util.pd.DataFrame):
            data = self.data.iloc[:0]
        elif isinstance(self.data, dict):
            data = {k: v[:0] for k, v in self.data.items()}
        with util.disable_constant(self):
            self.data = data
        self.send(data)
51586
public void clear() {
        if (arrMask != null) {
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    arrMask[x][y] = false;
                }
            }
        }
    }
559504
public void clear() {
        int n = mSize;
        Object[] values = mValues;

        for (int i = 0; i < n; i++) {
            values[i] = null;
        }

        mSize = 0;
        mGarbage = false;
    }
829509
def clear(self):
        """"""
        for i in range(self.maxlevel):
            self._head[2+i] = self._tail
            self._tail[-1] = 0
        self._level = 1
813267
void clear() {
        offset = intLen = 0;
        for (int index=0, n=value.length; index < n; index++)
            value[index] = 0;
    }
195253
def clear(self):
        """"""
        for i, value in enumerate(self.buffer):
            self.buffer[i] = 0
1295791
public function resetStaticVariables()
    {
        \oxArticleHelper::cleanup();
        \oxSeoEncoderHelper::cleanup();
        \oxDeliveryHelper::cleanup();
        \oxManufacturerHelper::cleanup();
        \oxAdminViewHelper::cleanup();
        \oxVendorHelper::cleanup();
    }
1256282
public function clear()
	{
		$classvars = get_class_vars(__CLASS__);

		foreach ($classvars as $property => $value)
		{
			if ('_s_' == substr($property, 0, 3)) // Don't touch static variables
			{
				continue;
			}

			unset($this->$property);
			$this->$property = $value;
		}

		$objvars = get_object_vars($this);

		foreach ($objvars as $property => $value)
		{
			if (!array_key_exists($property, $classvars))
			{
				unset($this->$property);
			}
		}

		return true;
	}
314818
public void clear() {
    this.posLiterals = new HashMap<>();
    this.negLiterals = new HashMap<>();
    this.generatedVariables = new HashSet<>();
    this.nots = new HashMap<>();
    this.implications = new HashMap<>();
    this.equivalences = new HashMap<>();
    this.ands2 = new HashMap<>();
    this.ands3 = new HashMap<>();
    this.ands4 = new HashMap<>();
    this.andsN = new HashMap<>();
    this.ors2 = new HashMap<>();
    this.ors3 = new HashMap<>();
    this.ors4 = new HashMap<>();
    this.orsN = new HashMap<>();
    this.pbConstraints = new HashMap<>();
    this.ccCounter = 0;
    this.pbCounter = 0;
    this.cnfCounter = 0;
  }
740997
def clear_globals(self):
        """"""

        base_keys = ['cStringIO', 'IntType', 'KeyValueStore', 'undoable',
                     'is_generator_like', 'is_string_like', 'bz2', 'base64',
                     '__package__', 're', 'config', '__doc__', 'SliceType',
                     'CellAttributes', 'product', 'ast', '__builtins__',
                     '__file__', 'charts', 'sys', 'is_slice_like', '__name__',
                     'copy', 'imap', 'wx', 'ifilter', 'Selection', 'DictGrid',
                     'numpy', 'CodeArray', 'DataArray', 'datetime',
                     'vlcpanel_factory']

        for key in globals().keys():
            if key not in base_keys:
                globals().pop(key)