BELScriptWalker.g:278:1: unset_statement_group : 'UNSET' STATEMENT_GROUP_KEYWORD ;
550456
public final BELScriptWalker.unset_statement_group_return unset_statement_group() throws RecognitionException {
        BELScriptWalker.unset_statement_group_return retval = new BELScriptWalker.unset_statement_group_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree string_literal20=null;
        CommonTree STATEMENT_GROUP_KEYWORD21=null;

        CommonTree string_literal20_tree=null;
        CommonTree STATEMENT_GROUP_KEYWORD21_tree=null;

        try {
            // BELScriptWalker.g:278:22: ( 'UNSET' STATEMENT_GROUP_KEYWORD )
            // BELScriptWalker.g:279:5: 'UNSET' STATEMENT_GROUP_KEYWORD
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            string_literal20=(CommonTree)match(input,26,FOLLOW_26_in_unset_statement_group261); 
            string_literal20_tree = (CommonTree)adaptor.dupNode(string_literal20);

            adaptor.addChild(root_0, string_literal20_tree);

            _last = (CommonTree)input.LT(1);
            STATEMENT_GROUP_KEYWORD21=(CommonTree)match(input,STATEMENT_GROUP_KEYWORD,FOLLOW_STATEMENT_GROUP_KEYWORD_in_unset_statement_group263); 
            STATEMENT_GROUP_KEYWORD21_tree = (CommonTree)adaptor.dupNode(STATEMENT_GROUP_KEYWORD21);

            adaptor.addChild(root_0, STATEMENT_GROUP_KEYWORD21_tree);


                    activeStatementGroup = null;
                    sgAnnotationContext.clear();
                

            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
703902
def validate_unset_command(self, line: str, position: int, annotation: str) -> None:
        
        if annotation not in self.annotations:
            raise MissingAnnotationKeyWarning(self.get_line_number(), line, position, annotation)
1083314
public final void mGROUP() throws RecognitionException {
		try {
			int _type = GROUP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:634:7: ( ( 'GROUP' | 'group' ) )
			// druidG.g:634:9: ( 'GROUP' | 'group' )
			{
			// druidG.g:634:9: ( 'GROUP' | 'group' )
			int alt23=2;
			int LA23_0 = input.LA(1);
			if ( (LA23_0=='G') ) {
				alt23=1;
			}
			else if ( (LA23_0=='g') ) {
				alt23=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 23, 0, input);
				throw nvae;
			}

			switch (alt23) {
				case 1 :
					// druidG.g:634:10: 'GROUP'
					{
					match("GROUP"); 

					}
					break;
				case 2 :
					// druidG.g:634:20: 'group'
					{
					match("group"); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
1304757
public static String parseShowStatementSubcommand(String statement)
    {
        Matcher matcher = ShowToken.matcher(statement);
        if (matcher.matches()) {
            String commandWordTerminator = matcher.group(1);
            if (OneWhitespace.matcher(commandWordTerminator).matches()) {
                String trailings = matcher.group(3) + ";" + matcher.group(4);
                // In a valid command, both "trailings" groups should be empty.
                if (trailings.equals(";")) {
                    // Return the subcommand keyword -- possibly a valid one.
                    return matcher.group(2);
                }
                // For an invalid form of the command,
                // return an approximation of the garbage input.
                return matcher.group(2) + " " + trailings;
            }
            if (commandWordTerminator.equals("") || commandWordTerminator.equals(";")) {
                return commandWordTerminator; // EOL or ; reached before subcommand
            }
        }
        return null;
    }
812371
def handle_unset_list(self, line: str, position: int, tokens: ParseResults) -> ParseResults:
        
        for key in tokens['values']:
            if key in {BEL_KEYWORD_EVIDENCE, BEL_KEYWORD_SUPPORT}:
                self.evidence = None
            else:
                self.validate_unset_command(line, position, key)
                del self.annotations[key]

        return tokens
181866
public synchronized void remove(final int statementId) {
        MySQLBinaryStatement binaryStatement = getBinaryStatement(statementId);
        if (null != binaryStatement) {
            statementIdAssigner.remove(binaryStatement.getSql());
            binaryStatements.remove(statementId);
        }
    }
1312019
StatementDMQL compileTriggerSetStatement(Table table,
            RangeVariable[] rangeVars) {

        read();

        Expression[]   updateExpressions;
        int[]          columnMap;
        OrderedHashSet colNames = new OrderedHashSet();
        HsqlArrayList  exprList = new HsqlArrayList();
        RangeVariable[] targetRangeVars = new RangeVariable[]{
            rangeVars[TriggerDef.NEW_ROW] };

        readSetClauseList(targetRangeVars, colNames, exprList);

        columnMap         = table.getColumnIndexes(colNames);
        updateExpressions = new Expression[exprList.size()];

        exprList.toArray(updateExpressions);
        resolveUpdateExpressions(table, rangeVars, columnMap,
                                 updateExpressions, RangeVariable.emptyArray);

        StatementDMQL cs = new StatementDML(session, table, rangeVars,
                                            columnMap, updateExpressions,
                                            compileContext);

        return cs;
    }
2835
boolean setGroup(char group[], byte groupstring[])
    {
        if (group != null && groupstring != null && group.length > 0 &&
            groupstring.length > 0) {
            m_groupinfo_ = group;
            m_groupstring_ = groupstring;
            return true;
        }
        return false;
    }
1169260
def statement(self):
        
        return (self.assignment ^ self.expression) + Suppress(
            self.syntax.terminator)
687078
public static String parseEchoStatement(String statement)
    {
        Matcher matcher = EchoToken.matcher(statement);
        if (matcher.matches()) {
            String commandWordTerminator = matcher.group(1);
            if (OneWhitespace.matcher(commandWordTerminator).matches()) {
                return matcher.group(2);
            }
            return "";
        }
        return null;
    }
637357
public final BELScriptParser.set_statement_group_return set_statement_group() throws RecognitionException {
        BELScriptParser.set_statement_group_return retval = new BELScriptParser.set_statement_group_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token string_literal19=null;
        Token STATEMENT_GROUP_KEYWORD20=null;
        Token char_literal21=null;
        Token OBJECT_IDENT23=null;
        BELScriptParser.quoted_value_return quoted_value22 = null;


        Object string_literal19_tree=null;
        Object STATEMENT_GROUP_KEYWORD20_tree=null;
        Object char_literal21_tree=null;
        Object OBJECT_IDENT23_tree=null;

         paraphrases.push("in set statement group."); 
        try {
            // BELScript.g:66:5: ( 'SET' STATEMENT_GROUP_KEYWORD '=' ( quoted_value | OBJECT_IDENT ) )
            // BELScript.g:67:5: 'SET' STATEMENT_GROUP_KEYWORD '=' ( quoted_value | OBJECT_IDENT )
            {
            root_0 = (Object)adaptor.nil();

            string_literal19=(Token)match(input,24,FOLLOW_24_in_set_statement_group226); 
            string_literal19_tree = (Object)adaptor.create(string_literal19);
            adaptor.addChild(root_0, string_literal19_tree);

            STATEMENT_GROUP_KEYWORD20=(Token)match(input,STATEMENT_GROUP_KEYWORD,FOLLOW_STATEMENT_GROUP_KEYWORD_in_set_statement_group228); 
            STATEMENT_GROUP_KEYWORD20_tree = (Object)adaptor.create(STATEMENT_GROUP_KEYWORD20);
            adaptor.addChild(root_0, STATEMENT_GROUP_KEYWORD20_tree);

            char_literal21=(Token)match(input,25,FOLLOW_25_in_set_statement_group230); 
            char_literal21_tree = (Object)adaptor.create(char_literal21);
            adaptor.addChild(root_0, char_literal21_tree);

            // BELScript.g:67:39: ( quoted_value | OBJECT_IDENT )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==QUOTED_VALUE) ) {
                alt4=1;
            }
            else if ( (LA4_0==OBJECT_IDENT) ) {
                alt4=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // BELScript.g:67:40: quoted_value
                    {
                    pushFollow(FOLLOW_quoted_value_in_set_statement_group233);
                    quoted_value22=quoted_value();

                    state._fsp--;

                    adaptor.addChild(root_0, quoted_value22.getTree());

                    }
                    break;
                case 2 :
                    // BELScript.g:67:55: OBJECT_IDENT
                    {
                    OBJECT_IDENT23=(Token)match(input,OBJECT_IDENT,FOLLOW_OBJECT_IDENT_in_set_statement_group237); 
                    OBJECT_IDENT23_tree = (Object)adaptor.create(OBJECT_IDENT23);
                    adaptor.addChild(root_0, OBJECT_IDENT23_tree);


                    }
                    break;

            }


            }

            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;
    }
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;
    }
107372
def p_break_statement_2(self, p):
        
        p[0] = self.asttypes.Break(p[2])
        p[0].setpos(p)
1194837
public final BELScriptWalker.set_statement_group_return set_statement_group() throws RecognitionException {
        BELScriptWalker.set_statement_group_return retval = new BELScriptWalker.set_statement_group_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        CommonTree _first_0 = null;
        CommonTree _last = null;

        CommonTree qv=null;
        CommonTree oi=null;
        CommonTree string_literal15=null;
        CommonTree STATEMENT_GROUP_KEYWORD16=null;
        CommonTree char_literal17=null;

        CommonTree qv_tree=null;
        CommonTree oi_tree=null;
        CommonTree string_literal15_tree=null;
        CommonTree STATEMENT_GROUP_KEYWORD16_tree=null;
        CommonTree char_literal17_tree=null;

        try {
            // BELScriptWalker.g:141:20: ( 'SET' STATEMENT_GROUP_KEYWORD '=' (qv= QUOTED_VALUE | oi= OBJECT_IDENT ) )
            // BELScriptWalker.g:142:5: 'SET' STATEMENT_GROUP_KEYWORD '=' (qv= QUOTED_VALUE | oi= OBJECT_IDENT )
            {
            root_0 = (CommonTree)adaptor.nil();

            _last = (CommonTree)input.LT(1);
            string_literal15=(CommonTree)match(input,24,FOLLOW_24_in_set_statement_group185); 
            string_literal15_tree = (CommonTree)adaptor.dupNode(string_literal15);

            adaptor.addChild(root_0, string_literal15_tree);

            _last = (CommonTree)input.LT(1);
            STATEMENT_GROUP_KEYWORD16=(CommonTree)match(input,STATEMENT_GROUP_KEYWORD,FOLLOW_STATEMENT_GROUP_KEYWORD_in_set_statement_group187); 
            STATEMENT_GROUP_KEYWORD16_tree = (CommonTree)adaptor.dupNode(STATEMENT_GROUP_KEYWORD16);

            adaptor.addChild(root_0, STATEMENT_GROUP_KEYWORD16_tree);

            _last = (CommonTree)input.LT(1);
            char_literal17=(CommonTree)match(input,25,FOLLOW_25_in_set_statement_group189); 
            char_literal17_tree = (CommonTree)adaptor.dupNode(char_literal17);

            adaptor.addChild(root_0, char_literal17_tree);

            // BELScriptWalker.g:142:39: (qv= QUOTED_VALUE | oi= OBJECT_IDENT )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==QUOTED_VALUE) ) {
                alt4=1;
            }
            else if ( (LA4_0==OBJECT_IDENT) ) {
                alt4=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // BELScriptWalker.g:142:40: qv= QUOTED_VALUE
                    {
                    _last = (CommonTree)input.LT(1);
                    qv=(CommonTree)match(input,QUOTED_VALUE,FOLLOW_QUOTED_VALUE_in_set_statement_group194); 
                    qv_tree = (CommonTree)adaptor.dupNode(qv);

                    adaptor.addChild(root_0, qv_tree);


                    }
                    break;
                case 2 :
                    // BELScriptWalker.g:142:58: oi= OBJECT_IDENT
                    {
                    _last = (CommonTree)input.LT(1);
                    oi=(CommonTree)match(input,OBJECT_IDENT,FOLLOW_OBJECT_IDENT_in_set_statement_group200); 
                    oi_tree = (CommonTree)adaptor.dupNode(oi);

                    adaptor.addChild(root_0, oi_tree);


                    }
                    break;

            }


                    final String name;
                    if (qv != null) {
                        name = qv.toString();
                    } else if (oi != null) {
                        name = oi.toString();
                    } else {
                        throw new IllegalStateException("Did not understand statement group value, expecting quoted value or object identifier.");
                    }

                    activeStatementGroup = new BELStatementGroup(name);
                    statementGroups.add(activeStatementGroup);
                

            }

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return retval;
    }
772601
def _usage_unallocated(raw):
    '''
    
    '''
    ret = {}
    for line in raw.split("\n")[1:]:
        keyset = re.sub(r"\s+", " ", line.strip()).split(" ")
        if len(keyset) == 2:
            ret[keyset[0]] = keyset[1]

    return ret
881899
@Override
    public void removedStatement(final Statement s) {
        if (Operation.REMOVE == statements.get(s)) {
            return;
        }
        try {
            // if it's not about the right kind of node, ignore it.
            final Resource subject = s.getSubject();
            validateSubject(subject);
            LOGGER.trace(">> removing statement {}", s);

            final FedoraResource resource = idTranslator.convert(subject);
            final FedoraResource description = resource.getDescription();

            // special logic for handling rdf:type updates.
            // if the object is an already-existing mixin, update
            // the node's mixins. If it isn't, just treat it normally.
            final Property property = s.getPredicate();
            final RDFNode objectNode = s.getObject();

            if (property.equals(RDF.type) && objectNode.isResource()) {
                final Resource mixinResource = objectNode.asResource();
                jcrRdfTools.removeMixin(description, mixinResource, s.getModel().getNsPrefixMap());
                statements.put(s, Operation.REMOVE);
                return;
            }

            jcrRdfTools.removeProperty(description, property, objectNode, s.getModel().getNsPrefixMap());
            statements.put(s, Operation.REMOVE);
        } catch (final ConstraintViolationException e) {
            throw e;
        } catch (final RepositoryException | RepositoryRuntimeException e) {
            exceptions.add(e);
        }

    }
1280785
function deleteGroup(group) {
  if (!runningAsRoot()) return;
  if (!group) throw new Error('You must provide a group to delete');
  if (!groupExists(group)) {
    return;
  }
  const groupdelBin = _safeLocateBinary('groupdel');
  const delgroupBin = _safeLocateBinary('delgroup');

  if (isPlatform('linux')) {
    if (groupdelBin !== null) { // most modern systems
      runProgram(groupdelBin, [group]);
    } else {
      if (_isBusyboxBinary(delgroupBin)) { // busybox-based systems
        runProgram(delgroupBin, [group]);
      } else {
        throw new Error(`Don't know how to delete group ${group} on this strange linux`);
      }
    }
  } else if (isPlatform('osx')) {
    runProgram('dscl', ['.', '-delete', `/Groups/${group}`]);
  } else if (isPlatform('windows')) {
    throw new Error(`Don't know how to delete group ${group} on Windows`);
  } else {
    throw new Error(`Don't know how to delete group ${group} on the current platformp`);
  }
}