BELScript.g:88:1: unset : 'UNSET' ( OBJECT_IDENT | IDENT_LIST ) ;
171566
public final BELScriptParser.unset_return unset() throws RecognitionException {
        BELScriptParser.unset_return retval = new BELScriptParser.unset_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal31=null;
        Token set32=null;

        Object string_literal31_tree=null;
        Object set32_tree=null;

         paraphrases.push("in unset."); 
        try {
            // BELScript.g:91:5: ( 'UNSET' ( OBJECT_IDENT | IDENT_LIST ) )
            // BELScript.g:92:5: 'UNSET' ( OBJECT_IDENT | IDENT_LIST )
            {
            root_0 = (Object)adaptor.nil();

            string_literal31=(Token)match(input,26,FOLLOW_26_in_unset381); 
            string_literal31_tree = (Object)adaptor.create(string_literal31);
            adaptor.addChild(root_0, string_literal31_tree);

            set32=(Token)input.LT(1);
            if ( input.LA(1)==OBJECT_IDENT||input.LA(1)==IDENT_LIST ) {
                input.consume();
                adaptor.addChild(root_0, (Object)adaptor.create(set32));
                state.errorRecovery=false;
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

             paraphrases.pop(); 
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
472676
private Object js_unescape(Object[] args)
    {
        String s = ScriptRuntime.toString(args, 0);
        int firstEscapePos = s.indexOf('%');
        if (firstEscapePos >= 0) {
            int L = s.length();
            char[] buf = s.toCharArray();
            int destination = firstEscapePos;
            for (int k = firstEscapePos; k != L;) {
                char c = buf[k];
                ++k;
                if (c == '%' && k != L) {
                    int end, start;
                    if (buf[k] == 'u') {
                        start = k + 1;
                        end = k + 5;
                    } else {
                        start = k;
                        end = k + 2;
                    }
                    if (end <= L) {
                        int x = 0;
                        for (int i = start; i != end; ++i) {
                            x = Kit.xDigitToInt(buf[i], x);
                        }
                        if (x >= 0) {
                            c = (char)x;
                            k = end;
                        }
                    }
                }
                buf[destination] = c;
                ++destination;
            }
            s = new String(buf, 0, destination);
        }
        return s;
    }
647555
def unregisterAddon(cls, name):
        
        prop = '_{0}__addons'.format(cls.__name__)
        cmds = getattr(cls, prop, {})
        cmds.pop(name, None)
11166
public final BELScriptParser.unset_statement_group_return unset_statement_group() throws RecognitionException {
        BELScriptParser.unset_statement_group_return retval = new BELScriptParser.unset_statement_group_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal29=null;
        Token STATEMENT_GROUP_KEYWORD30=null;

        Object string_literal29_tree=null;
        Object STATEMENT_GROUP_KEYWORD30_tree=null;

         paraphrases.push("in unset statement group."); 
        try {
            // BELScript.g:84:5: ( 'UNSET' STATEMENT_GROUP_KEYWORD )
            // BELScript.g:85:5: 'UNSET' STATEMENT_GROUP_KEYWORD
            {
            root_0 = (Object)adaptor.nil();

            string_literal29=(Token)match(input,26,FOLLOW_26_in_unset_statement_group340); 
            string_literal29_tree = (Object)adaptor.create(string_literal29);
            adaptor.addChild(root_0, string_literal29_tree);

            STATEMENT_GROUP_KEYWORD30=(Token)match(input,STATEMENT_GROUP_KEYWORD,FOLLOW_STATEMENT_GROUP_KEYWORD_in_unset_statement_group342); 
            STATEMENT_GROUP_KEYWORD30_tree = (Object)adaptor.create(STATEMENT_GROUP_KEYWORD30);
            adaptor.addChild(root_0, STATEMENT_GROUP_KEYWORD30_tree);


            }

            retval.stop = input.LT(-1);

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

             paraphrases.pop(); 
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
244203
def unset(ctx, key):
    ''''''
    file = ctx.obj['FILE']
    quote = ctx.obj['QUOTE']
    success, key = unset_key(file, key, quote)
    if success:
        click.echo("Successfully removed %s" % key)
    else:
        exit(1)
1165668
def unset_os_environ(variables_mapping):
    
    for variable in variables_mapping:
        os.environ.pop(variable)
        logger.log_debug("Unset OS environment variable: {}".format(variable))
823625
def RemoveObject(self, identifier):
    
    if identifier not in self._values:
      raise KeyError('Missing cached object for identifier: {0:s}'.format(
          identifier))

    del self._values[identifier]
1308336
function(attr, options) {
      (options || (options = {})).unset = true;
      return this.set(attr, null, options);
    }
377326
def unbind(self, format, *args):
        
        return lib.zsock_unbind(self._as_parameter_, format, *args)
322873
def preprocess_belscript(lines):
    

    set_flag = False
    for line in lines:
        if set_flag is False and re.match("SET", line):
            set_flag = True
            set_line = [line.rstrip()]
        # SET following SET
        elif set_flag and re.match("SET", line):
            yield f"{' '.join(set_line)}\n"
            set_line = [line.rstrip()]
        # Blank line following SET yields single line SET
        elif set_flag and re.match("\s+$", line):
            yield f"{' '.join(set_line)}\n"
            yield line
            set_flag = False

        # Append second, third, ... lines to SET
        elif set_flag:
            set_line.append(line.rstrip())
        else:
            yield line
907017
def _unset(self, pos):
        """"""
        assert 0 <= pos < self.len
        self._datastore.unsetbit(pos)
1289078
def p_identlist(self, t):
    '''              
                  '''
    if len(t)==5 : 
      #print(t[1],t[2],t[3],t[4])
      t[0] = t[1]+t[2]+t[3]+t[4]
    elif len(t)==4 : 
      #print(t[1],t[2],t[3])
      t[0] = t[1]+t[2]+t[3]
    elif len(t)==3 : 
      #print(t[1],t[2])
      t[0] = t[1]+t[2]
    elif len(t)==2 :
      #print(t[0],t[1])
      t[0]=t[1]
    else:
      print("Syntax error at '",str(t),"'")
158055
def handle_unset_statement_group(self, line: str, position: int, tokens: ParseResults) -> ParseResults:
        
        if self.statement_group is None:
            raise MissingAnnotationKeyWarning(self.get_line_number(), line, position, BEL_KEYWORD_STATEMENT_GROUP)
        self.statement_group = None
        return tokens
85873
def nl_list_del(obj):
    
    obj.next.prev = obj.prev
    obj.prev.next_ = obj.next_
233053
function offsetUnsetList()
    {
        $v = $this->getValue();
        if (is_array($v)){
            $arg = func_get_args();
            if (isset($arg[0]) && is_array($arg[0])) $arg = $arg[0];
            foreach ($arg as $name){
                $this->_interfaces[$name]->_maker = null;
                unset($this->_interfaces[$name]);
                unset($v[$name]);
            }
            $this->set($v);
        }
    }
160934
def change_identifiers(datadf, split_dict):
    """"""
    for rid, name in split_dict.items():
        datadf.loc[datadf["runIDs"] == rid, "dataset"] = name
586694
async def unset_lock(self, resource, lock_identifier):
        
        try:
            with await self.connect() as redis:
                await redis.eval(
                    self.unset_lock_script,
                    keys=[resource],
                    args=[lock_identifier]
                )
        except aioredis.errors.ReplyError as exc:  # script fault
            self.log.debug('Can not unset lock "%s" on %s',
                           resource, repr(self))
            raise LockError('Can not unset lock') from exc
        except (aioredis.errors.RedisError, OSError) as exc:
            self.log.error('Can not unset lock "%s" on %s: %s',
                           resource, repr(self), repr(exc))
            raise LockError('Can not set lock') from exc
        except asyncio.CancelledError:
            self.log.debug('Lock "%s" unset is cancelled on %s',
                           resource, repr(self))
            raise
        except Exception as exc:
            self.log.exception('Can not unset lock "%s" on %s',
                               resource, repr(self))
            raise
        else:
            self.log.debug('Lock "%s" is unset on %s', resource, repr(self))