program: (statement)*
557883
def program(self):
        
        root = Program()

        while self.token.nature != Nature.EOF:
            root.children.append(self.statement())

        return root
244719
public void execute(String statement) throws SQLException {
		if (logger.isDebugEnabled()) {
			logger.debug("Executing SQL statement [" + statement + "]");
		}
		
		Connection connection = null;
		Statement stm = null;
		
		try{
			connection = ds.getConnection();
			stm = connection.createStatement();			
			stm.execute(statement);
		} catch (SQLException e) {
			throw e;
		}finally{
			if(stm!=null) stm.close();
			if(connection!=null) connection.close();			
		}
				
	}
1302913
def assign(self, expr):
        """"""
        name = self.variable()
        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
        return ast.Name(name, ast.Load())
508615
def with_stmt_handle(self, tokens):
        """"""
        internal_assert(len(tokens) == 2, "invalid with statement tokens", tokens)
        withs, body = tokens
        if len(withs) == 1 or self.target_info >= (2, 7):
            return "with " + ", ".join(withs) + body
        else:
            return (
                "".join("with " + expr + ":\n" + openindent for expr in withs[:-1])
                + "with " + withs[-1] + body
                + closeindent * (len(withs) - 1)
            )
644770
function enterStatement(node) {
            const line = node.loc.start.line;

            /*
             * Skip to allow non-block statements if this is direct child of control statements.
             * `if (a) foo();` is counted as 1.
             * But `if (a) foo(); else foo();` should be counted as 2.
             */
            if (SINGLE_CHILD_ALLOWED.test(node.parent.type) &&
                node.parent.alternate !== node
            ) {
                return;
            }

            // Update state.
            if (line === lastStatementLine) {
                numberOfStatementsOnThisLine += 1;
            } else {
                reportFirstExtraStatementAndClear();
                numberOfStatementsOnThisLine = 1;
                lastStatementLine = line;
            }

            // Reports if the node violated this rule.
            if (numberOfStatementsOnThisLine === maxStatementsPerLine + 1) {
                firstExtraStatement = firstExtraStatement || node;
            }
        }
1351567
private Object exec(StatementContext statement) {
    if (statement == null)
      return null;
    return statement.accept(visitor);
  }
1360353
def program(self, prog, offset = 0):
		
		for addr, word in enumerate(prog):
			self.program_word(offset + addr, word)
445787
def add_statement(self, line: str, lineno: Optional[int] = None) -> None:
        ''''''
        # there can be only one statement block
        if self.category() != 'statements':
            self.values = [line]
        else:
            self.values.append(line)
        if self.statements and self.statements[-1][0] == '!':
            self.statements[-1][-1] += line
        else:
            self.statements.append(['!', line])
        if lineno:
            self.lineno = lineno
611371
public void bind(SQLiteStatement statement) {
		if (this.compiledStatement != null) {
			// already binded
			return;
		}

		int index = 1;

		statement.clearBindings();
		Object value;

		for (int j = 0; j < args.size(); j++) {
			value = args.get(j);
			switch (valueType.get(index - 1)) {
			case BOOLEAN:
				statement.bindLong(index, (long) (((Boolean) value) == true ? 1 : 0));
				break;
			case BYTE:
				statement.bindLong(index, (byte) value);
				break;
			case SHORT:
				statement.bindLong(index, (short) value);
				break;
			case INTEGER:
				statement.bindLong(index, (int) value);
				break;
			case CHARACTER:
				statement.bindLong(index, Character.getNumericValue((char)value));
				break;
			case LONG:
				statement.bindLong(index, (long) value);
				break;
			case BYTE_ARRAY:
				statement.bindBlob(index, (byte[]) value);
				break;
			case FLOAT:
				statement.bindDouble(index, (float) value);
				break;
			case DOUBLE:
				statement.bindDouble(index, (double) value);
				break;
			case NULL:
				statement.bindNull(index);
				break;
			case STRING:
				statement.bindString(index, (String) value);
				break;
			}
			index++;
		}

		for (int i = 0; i < whereArgs.size(); i++, index++) {
			statement.bindString(index, whereArgs.get(i));
		}
	}
607200
function postprocessProgram(program) {
      var body = program.body;

      if (body.length === 0) {
        return;
      }

      if (usesMorph(body[0])) {
        body.unshift(buildText(''));
      }

      if (usesMorph(body[body.length-1])) {
        body.push(buildText(''));
      }
    }
967095
function first_in_statement(output) {
        var a = output.stack(), i = a.length, node = a[--i], p = a[--i];
        while (i > 0) {
            if (p instanceof AST_Statement && p.body === node)
                return true;
            if ((p instanceof AST_Seq           && p.car === node        ) ||
                (p instanceof AST_Call          && p.expression === node && !(p instanceof AST_New) ) ||
                (p instanceof AST_Dot           && p.expression === node ) ||
                (p instanceof AST_Sub           && p.expression === node ) ||
                (p instanceof AST_Conditional   && p.condition === node  ) ||
                (p instanceof AST_Binary        && p.left === node       ) ||
                (p instanceof AST_UnaryPostfix  && p.expression === node ))
            {
                node = p;
                p = a[--i];
            } else {
                return false;
            }
        }
    }
1217113
def expression_statement(self):
        
        node = self.assignment()
        self._process(Nature.SEMI)
        return node
883414
def eval(self, statement, ctxt=None):
        
        self._no_debug = True

        statement = statement.strip()

        if not statement.endswith(";"):
            statement += ";"

        ast = self._parse_string(statement, predefines=False)

        self._dlog("evaluating statement: {}".format(statement))
        
        try:
            res = None
            for child in ast.children():
                res = self._handle_node(child, self._scope, self._ctxt, self._stream)
            return res
        except errors.InterpReturn as e:
            return e.value
        finally:
            self._no_debug = False
1285174
public static void main(String args[]) {
        Statement stmts[] = null;
        try {
            stmts = getStatements(args[0]);
        } catch (Throwable e) {
            System.out.println(e.getMessage());
            return;
        }
        for (Statement s : stmts) {
            System.out.print(s.statement);
        }
    }
528481
function (out, statement) {
                    var parsename = /^@(\w+):(\w+)$/.exec(statement.name);
                    if (!parsename || parsename.length != 3) {
                        return out.logError(statement, statementsSingleton.INVALID_WIDGET_SYNTAX);
                    }
                    var libName = parsename[1];
                    var widgetName = parsename[2];
                    var libclasspath = out.templateParam.$wlibs[libName];
                    if (libclasspath === undefined) {
                        return out.logError(statement, statementsSingleton.UNDECLARED_WIDGET_LIBRARY, [libName]);
                    }
                    if (!out.dontLoadWidgetLibs) {
                        var wlib = out.wlibs[libName];
                        if (!wlib) {
                            wlib = Aria.getClassRef(libclasspath);
                            if (!ariaUtilsType.isInstanceOf(wlib, "aria.widgetLibs.WidgetLib")) {
                                return out.logError(statement, statementsSingleton.INVALID_WIDGET_LIBRARY, [libName,
                                        libclasspath]);
                            }
                            out.wlibs[libName] = wlib;
                        }
                        var dep = wlib.getWidgetDependencies(widgetName, out.allDependencies);
                        if (!dep) {
                            return out.logError(statement, statementsSingleton.UNKNOWN_WIDGET, [statement.name]);
                        }
                        out.addDependencies(dep);
                    }
                    var param = statement.paramBlock;
                    if (param.length === 0) {
                        param = "undefined";
                    } else {
                        // Look for use of standard binding transforms
                        // and automatically add those to dependencies
                        var transformDependencies = [];
                        var regEx = /[\'\"](aria\.widgets\.transform\.(.+))[\'\"]/g;
                        var myMatch = regEx.exec(param);
                        while (myMatch) {
                            transformDependencies.push(myMatch[1]);
                            myMatch = regEx.exec(param);
                        }
                        out.addDependencies(transformDependencies);
                    }

                    if (out.debug && param != "undefined") {
                        param = out.wrapExpression(param, statement, "this.EXCEPTION_IN_CONTROL_PARAMETERS");
                    }

                    if (statement.content) {
                        // container widget
                        out.writeln("if (this.__$beginContainerWidget(", out.stringify(libclasspath), ",", out.stringify(widgetName), ",(", param, "),", statement.lineNumber, ")) {");
                        out.increaseIndent();
                        out.processContent(statement.content);
                        out.writeln("this.__$endContainerWidget();");
                        out.decreaseIndent();
                        out.writeln("}");
                    } else {
                        // simple widget
                        out.writeln("this.__$processWidgetMarkup(", out.stringify(libclasspath), ",", out.stringify(widgetName), ",(", param, "),", statement.lineNumber, ");");
                    }
                    statement.properties = {
                        libName: libName,
                        libClasspath: libclasspath,
                        widgetName: widgetName
                    };
                }
1221317
def p_while_statement(p):
    ''''''
    if len(p) == 2:
        p[0] = p[1]
    else:
        p[0] = ast.Block(p[2], lineno=p.lineno(1))
924411
def p_statement_if_then_endif(p):
    
    cond_ = p[1]
    stat_ = p[2]
    endif_ = p[3]
    p[0] = make_sentence('IF', cond_, make_block(stat_, endif_), lineno=p.lineno(1))