# File kwartz.rb, line 2712
        def exec_stmt(stmt_node, arg1=nil, arg2=nil)
            case stmt_node.token
            when :set
                node = stmt_node.left
                op       = node.token         # = += -= *= /= %=
                lhs_node = node.left
                rhs_node = node.right
                #Kwartz::assert() unless lhs_node.token == :variable
                if lhs_node.token == :variable then
                    varname = lhs_node.left
                    if _debut?(varname) then
                        unless op == '=' then
                            msg = "#{varname}: uninitialized local var is used, or tryng to assign into global var."
                            @warnings << msg
                        end
                        _regist(varname, :local, false)
                        exec_expr(rhs_node, arg1, arg2)
                        _set_initialized(varname)
                    else
                        if _scope(varname) == :global then
                            msg = "#{varname}: trying to assign into global var."
                            @warnings << msg
                        end
                        exec_expr(rhs_node, arg1, arg2)
                    end
                else
                    #msg = "left-hand of assignment should be a normal variable."
                    #@warnings << msg
                    exec_expr(lhs_node, arg1, arg2)
                    exec_expr(rhs_node, arg1, arg2)
                end
                
            when :foreach
                Kwartz::assert() unless stmt_node.left.token == '='
                loopvar_node = stmt_node.left.left
                listvar_node = stmt_node.left.right
                nodelist     = stmt_node.right
                #Kwartz::assert() unless loopvar_node.token == :variable
                if loopvar_node.token == :variable then
                    varname = loopvar_node.left
                    if _debut?(varname) then
                        _regist(varname, :local, false)
                        exec_expr(listvar_node, arg1, arg2)
                        _set_initialized(varname)
                    elsif _scope(varname) == :global then
                        msg = "#{varname}: global var is used as loop var."
                        @warnings << msg
                        exec_expr(listvar_node, arg1, arg2)
                    end
                else
                    #msg = "loop var should be a normal variable."
                    #@warnings << msg
                    exec_expr(loopvar_node, arg1, arg2)
                    exec_expr(listvar_node, arg1, arg2)
                end
                exec_nodelist(nodelist, arg1, arg2)

            when :print
                exec_expr(stmt_node.left, arg1, arg2)

            when :while
                #cond_expr = stmt_node.left
                #nodelist  = stmt_node.right
                cond_expr = stmt_node.condition
                nodelist  = stmt_node.left
                exec_expr(cond_expr, arg1, arg2)
                exec_nodelist(nodelist, arg1, arg2)
                
            when :if
                cond_expr     = stmt_node.condition
                then_nodelist = stmt_node.left
                else_node     = stmt_node.right
                exec_expr(cond_expr, arg1, arg2)
                exec_nodelist(then_nodelist, arg1, arg2)
                else_node.execute(self, arg1, arg2) if else_node

            when :rawcode

            when :macro
                macro_name = stmt_node.left
                nodelist = stmt_node.right
                @macros[macro_name] = nodelist
                
            when :expand
                macro_name = stmt_node.left
                nodelist = @macros[macro_name]
                unless nodelist
                    msg = "'#{macro_name}': no such macro."
                    raise AnalysisError.new(msg)
                end
                exec_nodelist(nodelist, arg1, arg2)
                
            else
                Kwartz::assert()
            end
        end