diff --git a/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java b/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java index e729dd3898ed..b98bd4c9509c 100644 --- a/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java +++ b/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java @@ -15,12 +15,11 @@ */ package com.intellij.debugger; +import com.intellij.debugger.impl.DebuggerManagerImpl; +import com.intellij.debugger.settings.DebuggerSettings; import com.intellij.execution.ExecutionException; import com.intellij.execution.ExecutionResult; -import com.intellij.execution.configurations.RemoteConnection; -import com.intellij.execution.configurations.RemoteState; -import com.intellij.execution.configurations.RunProfileState; -import com.intellij.execution.configurations.SearchScopeProvider; +import com.intellij.execution.configurations.*; import com.intellij.execution.runners.ExecutionEnvironment; import com.intellij.psi.search.GlobalSearchScope; import org.jetbrains.annotations.NotNull; @@ -31,6 +30,7 @@ public class DefaultDebugEnvironment implements DebugEnvironment { private final boolean myPollConnection; private final ExecutionEnvironment environment; private final RunProfileState state; + private final boolean myNeedParametersSet; public DefaultDebugEnvironment(@NotNull ExecutionEnvironment environment, @NotNull RunProfileState state, RemoteConnection remoteConnection, boolean pollConnection) { this.environment = environment; @@ -39,10 +39,19 @@ public class DefaultDebugEnvironment implements DebugEnvironment { myPollConnection = pollConnection; mySearchScope = SearchScopeProvider.createSearchScope(environment.getProject(), environment.getRunProfile()); + myNeedParametersSet = remoteConnection.isServerMode() && remoteConnection.isUseSockets() && "0".equals(remoteConnection.getAddress()); } @Override public ExecutionResult createExecutionResult() throws ExecutionException { + // debug port may have changed, reinit parameters just in case + if (myNeedParametersSet && state instanceof JavaCommandLine) { + DebuggerManagerImpl.createDebugParameters(((JavaCommandLine)state).getJavaParameters(), + true, + DebuggerSettings.SOCKET_TRANSPORT, + myRemoteConnection.getAddress(), + false); + } return state.execute(environment.getExecutor(), environment.getRunner()); } diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java index ed583f404a05..9c14f9379e26 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java @@ -493,7 +493,7 @@ public abstract class DebugProcessImpl extends UserDataHolderBase implements Deb if (address == null) { throw new CantRunException(DebuggerBundle.message("error.no.debug.listen.port")); } - // negative port number means the caller leaves to debugger to decide at which port to listen + // zero port number means the caller leaves to debugger to decide at which port to listen //noinspection HardCodedStringLiteral final Connector.Argument portArg = myConnection.isUseSockets() ? myArguments.get("port") : myArguments.get("name"); if (portArg != null) { @@ -504,7 +504,13 @@ public abstract class DebugProcessImpl extends UserDataHolderBase implements Deb if (timeoutArg != null) { timeoutArg.setValue("0"); // wait forever } - connector.startListening(myArguments); + String listeningAddress = connector.startListening(myArguments); + String port = StringUtil.substringAfter(listeningAddress, ":"); + if (port != null) { + listeningAddress = port; + } + myConnection.setAddress(listeningAddress); + myDebugProcessDispatcher.getMulticaster().connectorIsReady(); try { return connector.accept(myArguments); diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/GenericDebuggerRunner.java b/java/debugger/impl/src/com/intellij/debugger/impl/GenericDebuggerRunner.java index eb2549f31cb8..1a2f1442cb67 100644 --- a/java/debugger/impl/src/com/intellij/debugger/impl/GenericDebuggerRunner.java +++ b/java/debugger/impl/src/com/intellij/debugger/impl/GenericDebuggerRunner.java @@ -73,8 +73,12 @@ public class GenericDebuggerRunner extends JavaPatchableProgramRunner false") + protected static boolean isCallOf(@Nullable PsiMethodCallExpression expression, + @NotNull String className, + @NotNull String methodName, + int parametersCount) { + if (expression == null) return false; + final PsiMethod method = expression.resolveMethod(); + if (method != null && methodName.equals(method.getName()) && method.getParameterList().getParametersCount() == parametersCount) { + final PsiClass containingClass = method.getContainingClass(); + if (containingClass != null && className.equals(containingClass.getQualifiedName())) { + return true; + } + } + return false; + } + + private static abstract class CallChainFixBase implements LocalQuickFix { + @Nls + @NotNull + @Override + public String getName() { + return getFamilyName(); + } + + @Override + public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { + final PsiElement element = descriptor.getStartElement(); + if (element instanceof PsiMethodCallExpression) { + if (!FileModificationService.getInstance().preparePsiElementForWrite(element.getContainingFile())) return; + final PsiMethodCallExpression expression = (PsiMethodCallExpression)element; + final PsiExpression forEachMethodQualifier = expression.getMethodExpression().getQualifierExpression(); + if (forEachMethodQualifier instanceof PsiMethodCallExpression) { + final PsiMethodCallExpression previousExpression = (PsiMethodCallExpression)forEachMethodQualifier; + final PsiExpression qualifierExpression = previousExpression.getMethodExpression().getQualifierExpression(); + + if (qualifierExpression != null) { + final String text = createExpressionText(expression, previousExpression, qualifierExpression); + final PsiExpression newElement = JavaPsiFacade.getElementFactory(project).createExpressionFromText(text, null); + final PsiElement shortenedElement = JavaCodeStyleManager.getInstance(project).shortenClassReferences(newElement); + element.replace(shortenedElement); + } + } + } + } + + @NotNull + protected abstract String createExpressionText(@NotNull PsiMethodCallExpression methodCall, + @NotNull PsiMethodCallExpression qualifierCall, + @NotNull PsiExpression qualifierExpression); + } + + private static class ArraysAsListVarargFix extends CallChainFixBase { + + @Nls + @NotNull + @Override + public String getFamilyName() { + return "Replace Arrays.asList().stream() with Stream.of()"; + } + + @NotNull + protected String createExpressionText(@NotNull PsiMethodCallExpression methodCall, + @NotNull PsiMethodCallExpression qualifierCall, + @NotNull PsiExpression qualifierExpression) { + return (CommonClassNames.JAVA_UTIL_STREAM_STREAM + "." + OF_METHOD) + qualifierCall.getArgumentList().getText(); + } + } + + private static class ArraysAsListSingleArrayFix extends CallChainFixBase { + @Nls + @NotNull + @Override + public String getFamilyName() { + return "Replace Arrays.asList().stream() with Arrays.stream()"; + } + + @NotNull + protected String createExpressionText(@NotNull PsiMethodCallExpression methodCall, + @NotNull PsiMethodCallExpression qualifierCall, + @NotNull PsiExpression qualifierExpression) { + return (CommonClassNames.JAVA_UTIL_ARRAYS + "." + STREAM_METHOD) + qualifierCall.getArgumentList().getText(); + } + } + + private static class CollectionForEachFix extends CallChainFixBase { + @Nls + @NotNull + @Override + public String getFamilyName() { + return "Replace Collection.stream().forEach() with Collection.forEach()"; + } + + @NotNull + @Override + protected String createExpressionText(@NotNull PsiMethodCallExpression methodCall, + @NotNull PsiMethodCallExpression qualifierCall, + @NotNull PsiExpression qualifierExpression) { + return qualifierExpression.getText() + "." + FOR_EACH_METHOD + methodCall.getArgumentList().getText(); + } + } +} diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java index 7ee09739cf3e..ea83659ed1b6 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/ChangeMethodSignatureFromUsageFix.java @@ -38,6 +38,7 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.SuggestedNameInfo; import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.refactoring.RefactoringBundle; @@ -318,6 +319,7 @@ public class ChangeMethodSignatureFromUsageFix implements IntentionAction/*, Hig buf.append(presentableText); } else { + if (PsiPolyExpressionUtil.isPolyExpression(expression)) return null; PsiType exprType = RefactoringUtil.getTypeByExpression(expression); if (exprType == null) return null; if (exprType instanceof PsiDisjunctionType) { @@ -391,6 +393,7 @@ public class ChangeMethodSignatureFromUsageFix implements IntentionAction/*, Hig } else if (expression != null) { if (varargParam != null && pi >= parameters.length) return false; + if (PsiPolyExpressionUtil.isPolyExpression(expression)) return false; PsiType exprType = RefactoringUtil.getTypeByExpression(expression); if (exprType == null) return false; if (exprType instanceof PsiDisjunctionType) { diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateMethodFromMethodReferenceFix.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateMethodFromMethodReferenceFix.java index 3393fd232560..37cc769c22e0 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateMethodFromMethodReferenceFix.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateMethodFromMethodReferenceFix.java @@ -110,8 +110,17 @@ public class CreateMethodFromMethodReferenceFix extends CreateFromUsageBaseFix { expression = getMethodReference(); LOG.assertTrue(expression.isValid()); - if (!expression.isConstructor() && shouldCreateStaticMember(expression, targetClass)) { - PsiUtil.setModifierProperty(method, PsiModifier.STATIC, true); + boolean shouldBeAbstract = false; + if (!expression.isConstructor()) { + if (shouldCreateStaticMember(expression, targetClass)) { + PsiUtil.setModifierProperty(method, PsiModifier.STATIC, true); + } + else if (targetClass.isInterface()) { + shouldBeAbstract = true; + PsiCodeBlock body = method.getBody(); + assert body != null; + body.delete(); + } } final PsiElement context = PsiTreeUtil.getParentOfType(expression, PsiClass.class, PsiMethod.class); @@ -126,7 +135,7 @@ public class CreateMethodFromMethodReferenceFix extends CreateFromUsageBaseFix { final PsiSubstitutor substitutor = LambdaUtil.getSubstitutor(interfaceMethod, classResolveResult); final ExpectedTypeInfo[] expectedTypes = {new ExpectedTypeInfoImpl(interfaceReturnType, ExpectedTypeInfo.TYPE_OR_SUBTYPE, interfaceReturnType, TailType.NONE, null, ExpectedTypeInfoImpl.NULL)}; - CreateMethodFromUsageFix.doCreate(targetClass, method, false, + CreateMethodFromUsageFix.doCreate(targetClass, method, shouldBeAbstract, ContainerUtil.map2List(interfaceMethod.getParameterList().getParameters(), parameter -> Pair.create(null, substitutor.substitute(parameter.getType()))), PsiSubstitutor.EMPTY, expectedTypes, context); diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithStatementRangeAdjuster.java b/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithStatementRangeAdjuster.java new file mode 100644 index 000000000000..fadb59d5bae1 --- /dev/null +++ b/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithStatementRangeAdjuster.java @@ -0,0 +1,50 @@ +/* + * Copyright 2000-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInsight.generation.surroundWith; + +import com.intellij.codeInsight.CodeInsightUtil; +import com.intellij.openapi.util.TextRange; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiFile; +import com.intellij.psi.PsiStatement; +import com.intellij.psi.PsiWhiteSpace; +import com.intellij.psi.util.PsiTreeUtil; +import org.jetbrains.annotations.Nullable; + +public class JavaSurroundWithStatementRangeAdjuster implements SurroundWithRangeAdjuster { + + @Nullable + @Override + public TextRange adjustSurroundWithRange(PsiFile file, TextRange selectedRange) { + return selectedRange; + } + + @Nullable + @Override + public TextRange adjustSurroundWithRange(PsiFile file, TextRange selectedRange, boolean hasSelection) { + if (!hasSelection) { + int startOffset = selectedRange.getStartOffset(); + int endOffset = selectedRange.getEndOffset(); + if (CodeInsightUtil.findStatementsInRange(file, startOffset, endOffset).length == 0) { + PsiElement elementAtLineStart = PsiTreeUtil.skipSiblingsForward(file.findElementAt(startOffset), PsiWhiteSpace.class); + if (elementAtLineStart instanceof PsiStatement) { + return elementAtLineStart.getTextRange(); + } + } + } + return selectedRange; + } +} diff --git a/java/java-impl/src/com/intellij/codeInspection/javaDoc/JavadocHtmlLintAnnotator.kt b/java/java-impl/src/com/intellij/codeInspection/javaDoc/JavadocHtmlLintAnnotator.kt index 19210b793546..1f3a138fea47 100644 --- a/java/java-impl/src/com/intellij/codeInspection/javaDoc/JavadocHtmlLintAnnotator.kt +++ b/java/java-impl/src/com/intellij/codeInspection/javaDoc/JavadocHtmlLintAnnotator.kt @@ -47,13 +47,15 @@ import com.intellij.psi.util.PsiTreeUtil import com.sun.tools.doclint.DocLint import java.io.File -class JavadocHtmlLintAnnotator : ExternalAnnotator() { +class JavadocHtmlLintAnnotator(private val manual: Boolean = false) : + ExternalAnnotator() { + data class Info(val file: PsiFile) data class Anno(val row: Int, val col: Int, val error: Boolean, val message: String) data class Result(val annotations: List) override fun collectInformation(file: PsiFile): Info? = - if (isJava8SourceFile(file) && file.text.contains("/**") && isToolEnabled(file)) Info(file) else null + if (isJava8SourceFile(file) && "/**" in file.text && isToolEnabled(file)) Info(file) else null override fun doAnnotate(collectedInfo: Info): Result? { val file = collectedInfo.file.virtualFile!! @@ -116,7 +118,7 @@ class JavadocHtmlLintAnnotator : ExternalAnnotator { RefactoringUtil.replaceMovedMemberTypeParameters(methodCopy, PsiUtil.typeParametersIterable(mySourceClass), substitutor, elementFactory); Language language = myTargetSuperClass.getLanguage(); - final PsiMethod superClassMethod = myTargetSuperClass.findMethodBySignature(methodCopy, false); + final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySuperSignature(myTargetSuperClass, method.getSignature(substitutor), false); if (superClassMethod != null && superClassMethod.findDeepestSuperMethods().length == 0 || method.findSuperMethods(myTargetSuperClass).length == 0) { deleteOverrideAnnotationIfFound(methodCopy); diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java index 1482924ce681..314facb12f1d 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/PsiUtil.java @@ -47,6 +47,7 @@ import com.intellij.util.containers.EmptyIterable; import com.intellij.util.containers.HashMap; import gnu.trove.THashSet; import org.intellij.lang.annotations.MagicConstant; +import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -1069,12 +1070,14 @@ public final class PsiUtil extends PsiUtilCore { return false; } + @Contract("null, _ -> null") @Nullable public static PsiType extractIterableTypeParameter(@Nullable PsiType psiType, final boolean eraseTypeParameter) { final PsiType type = substituteTypeParameter(psiType, CommonClassNames.JAVA_LANG_ITERABLE, 0, eraseTypeParameter); return type != null ? type : substituteTypeParameter(psiType, CommonClassNames.JAVA_UTIL_COLLECTION, 0, eraseTypeParameter); } + @Contract("null, _, _, _ -> null") @Nullable public static PsiType substituteTypeParameter(@Nullable final PsiType psiType, @NotNull final String superClass, final int typeParamIndex, final boolean eraseTypeParameter) { diff --git a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java index 57c6d99f73c7..603031d375fc 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/RedundantCastUtil.java @@ -663,6 +663,10 @@ public class RedundantCastUtil { return; } } + + if (operand instanceof PsiFunctionalExpression && !castTo.equals(PsiTypesUtil.getExpectedTypeByParent(parent))) { + return; + } } if (arrayAccessAtTheLeftSideOfAssignment(parent, typeCast)) { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/CastInConditionalBranch.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/CastInConditionalBranch.java new file mode 100644 index 000000000000..6c94cd192494 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/redundantCast/CastInConditionalBranch.java @@ -0,0 +1,11 @@ +import java.util.function.Supplier; + +class Test { + { + Object o = true ? ((Supplier) () -> "") : null; + Supplier s1 = true ? ((' is redundant">Supplier) () -> "") : null; + Supplier s2 = true ? ((A) () -> "") : null; + } + + interface A extends Supplier {} +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDiamonds.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDiamonds.java index b9b435e0bffd..1a5b77c69dff 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDiamonds.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforeDiamonds.java @@ -1,4 +1,4 @@ -// "Change 1st parameter of method 'foo' from 'ArrayList' to 'HashSet'" "false" +// " Change signature of foo(ArrayList<String> HashSet<E>)" "false" import java.util.ArrayList; import java.util.HashSet; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforePolyExpressionInNonAssignablePosition.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforePolyExpressionInNonAssignablePosition.java new file mode 100644 index 000000000000..ff7dd0ae5fa9 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/changeMethodSignatureFromUsage8/beforePolyExpressionInNonAssignablePosition.java @@ -0,0 +1,10 @@ +// " Change signature of foo(boolean HashSet<E>)" "false" +import java.util.*; +class IntentionIssue { + void foo(boolean b) {} + void foo(ArrayList lst) {} + + void bar() { + foo(new HashSet<>()); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/afterAbstractInterfaceMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/afterAbstractInterfaceMethod.java new file mode 100644 index 000000000000..e07d97973614 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/afterAbstractInterfaceMethod.java @@ -0,0 +1,9 @@ +// "Create method 'fooBar'" "true" +class FooBar { + interface A { + void fooBar(); + } + void m(A a){ + Runnable r = a::fooBar; + } +} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/beforeAbstractInterfaceMethod.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/beforeAbstractInterfaceMethod.java new file mode 100644 index 000000000000..a8cc5dab693d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/createMethodFromMethodRef/beforeAbstractInterfaceMethod.java @@ -0,0 +1,7 @@ +// "Create method 'fooBar'" "true" +class FooBar { + interface A {} + void m(A a){ + Runnable r = a::fooBar; + } +} diff --git a/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection.java b/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection.java new file mode 100644 index 000000000000..a26ac9657fd1 --- /dev/null +++ b/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection.java @@ -0,0 +1,7 @@ +class Test { + { + for(int i = 0; i< 9; i++) { + System.out.println("42"); + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection_after.java b/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection_after.java new file mode 100644 index 000000000000..0f5fcb64a1a2 --- /dev/null +++ b/java/java-tests/testData/codeInsight/generation/surroundWith/java/SurroundWithStatementWithoutSelection_after.java @@ -0,0 +1,9 @@ +class Test { + { + if () { + for(int i = 0; i< 9; i++) { + System.out.println("42"); + } + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/afterAsListArrayStream.java b/java/java-tests/testData/inspection/streamApiCallChains/afterAsListArrayStream.java new file mode 100644 index 000000000000..22b16418ae76 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/afterAsListArrayStream.java @@ -0,0 +1,9 @@ +// "Replace Arrays.asList().stream() with Arrays.stream()" "true" + +import java.util.Arrays; + +class AsListArrayStream { + String max(String[] args) { + return Arrays.stream(args).max(String::compareTo); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/afterAsListLiteralStream.java b/java/java-tests/testData/inspection/streamApiCallChains/afterAsListLiteralStream.java new file mode 100644 index 000000000000..8dbe7c7ad935 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/afterAsListLiteralStream.java @@ -0,0 +1,10 @@ +// "Replace Arrays.asList().stream() with Stream.of()" "true" + +import java.util.Arrays; +import java.util.stream.Stream; + +class AsListLiteralStream { + Stream abc() { + return Stream.of("a", "b", "c"); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachLambda.java b/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachLambda.java new file mode 100644 index 000000000000..8d1cfef92e3d --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachLambda.java @@ -0,0 +1,11 @@ +// "Replace Collection.stream().forEach() with Collection.forEach()" "true" + +import java.util.Arrays; +import java.util.Collection; + +class Test { + void print() { + Collection def = Arrays.asList('d', 'e', 'f'); + def.forEach(c -> System.out.print(" " + c)); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachMethodRef.java b/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachMethodRef.java new file mode 100644 index 000000000000..70511036fe16 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/afterStreamForEachMethodRef.java @@ -0,0 +1,11 @@ +// "Replace Collection.stream().forEach() with Collection.forEach()" "true" + +import java.util.Arrays; +import java.util.Collection; + +class Test { + void print() { + Collection def = Arrays.asList('d', 'e', 'f'); + def.forEach(System.out::print); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListArrayStream.java b/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListArrayStream.java new file mode 100644 index 000000000000..fdebde74dee5 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListArrayStream.java @@ -0,0 +1,9 @@ +// "Replace Arrays.asList().stream() with Arrays.stream()" "true" + +import java.util.Arrays; + +class AsListArrayStream { + String max(String[] args) { + return Arrays.asList(args).stream().max(String::compareTo); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListLiteralStream.java b/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListLiteralStream.java new file mode 100644 index 000000000000..169d47c60338 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/beforeAsListLiteralStream.java @@ -0,0 +1,10 @@ +// "Replace Arrays.asList().stream() with Stream.of()" "true" + +import java.util.Arrays; +import java.util.stream.Stream; + +class AsListLiteralStream { + Stream abc() { + return Arrays.asList("a", "b", "c").stream(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachLambda.java b/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachLambda.java new file mode 100644 index 000000000000..877c4d7b5c3e --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachLambda.java @@ -0,0 +1,11 @@ +// "Replace Collection.stream().forEach() with Collection.forEach()" "true" + +import java.util.Arrays; +import java.util.Collection; + +class Test { + void print() { + Collection def = Arrays.asList('d', 'e', 'f'); + def.stream().forEach(c -> System.out.print(" " + c)); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachMethodRef.java b/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachMethodRef.java new file mode 100644 index 000000000000..72ebb3c96582 --- /dev/null +++ b/java/java-tests/testData/inspection/streamApiCallChains/beforeStreamForEachMethodRef.java @@ -0,0 +1,11 @@ +// "Replace Collection.stream().forEach() with Collection.forEach()" "true" + +import java.util.Arrays; +import java.util.Collection; + +class Test { + void print() { + Collection def = Arrays.asList('d', 'e', 'f'); + def.stream().forEach(System.out::print); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/refactoring/pullUp/SubstituteOverrideToMerge_after.java b/java/java-tests/testData/refactoring/pullUp/SubstituteOverrideToMerge_after.java index 08a2b05e7a3b..e3e051fe3262 100644 --- a/java/java-tests/testData/refactoring/pullUp/SubstituteOverrideToMerge_after.java +++ b/java/java-tests/testData/refactoring/pullUp/SubstituteOverrideToMerge_after.java @@ -1,7 +1,4 @@ abstract class C { - abstract void foo(T t); - - @Override void foo(T t) { } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java index bb6a9c97548d..5a821021f2ec 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/LambdaRedundantCastTest.java @@ -80,6 +80,7 @@ public class LambdaRedundantCastTest extends LightDaemonAnalyzerTestCase { } public void testInvalidResolveWithoutCast() { doTest();} + public void testCastInConditionalBranch() { doTest();} public void testRejectReturnTypeChange() throws Exception { doTest(); diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ChangeMethodSignatureFromUsage8Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ChangeMethodSignatureFromUsage8Test.java index d72907c0560f..0a4f58ca8bbf 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ChangeMethodSignatureFromUsage8Test.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/ChangeMethodSignatureFromUsage8Test.java @@ -19,6 +19,9 @@ import com.intellij.openapi.projectRoots.Sdk; import com.intellij.pom.java.LanguageLevel; import com.intellij.testFramework.IdeaTestUtil; +import java.util.ArrayList; +import java.util.LinkedList; + public class ChangeMethodSignatureFromUsage8Test extends LightQuickFixParameterizedTestCase { public void test() throws Exception { doAllTests(); } diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithTest.java b/java/java-tests/testSrc/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithTest.java index 56ab4c5182ba..5fa1417cb1c4 100644 --- a/java/java-tests/testSrc/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithTest.java +++ b/java/java-tests/testSrc/com/intellij/codeInsight/generation/surroundWith/JavaSurroundWithTest.java @@ -96,6 +96,10 @@ public class JavaSurroundWithTest extends LightCodeInsightTestCase { } } + public void testSurroundWithStatementWithoutSelection() throws Exception { + doTest(new JavaWithIfSurrounder()); + } + public void testSurroundNonExpressionWithParenthesis() throws Exception { doTest(new JavaWithParenthesesSurrounder()); } diff --git a/java/java-tests/testSrc/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspectionTest.java b/java/java-tests/testSrc/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspectionTest.java new file mode 100644 index 000000000000..c79fb02d6c61 --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInspection/SimplifyStreamApiCallChainsInspectionTest.java @@ -0,0 +1,47 @@ +/* + * Copyright 2000-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInspection; + +import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.testFramework.IdeaTestUtil; +import org.jetbrains.annotations.NotNull; + +/** + * @author Pavel.Dolgov + */ +public class SimplifyStreamApiCallChainsInspectionTest extends LightQuickFixParameterizedTestCase { + + @NotNull + @Override + protected LocalInspectionTool[] configureLocalInspectionTools() { + return new LocalInspectionTool[]{new SimplifyStreamApiCallChainsInspection()}; + } + + public void test() throws Exception { + doAllTests(); + } + + @Override + protected Sdk getProjectJDK() { + return IdeaTestUtil.getMockJdk18(); + } + + @Override + protected String getBasePath() { + return "/inspection/streamApiCallChains"; + } +} diff --git a/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameHddTest.groovy b/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameHddTest.groovy index 7398951b99f0..f2f92af8b12d 100644 --- a/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameHddTest.groovy +++ b/java/java-tests/testSrc/com/intellij/navigation/ChooseByNameHddTest.groovy @@ -14,11 +14,18 @@ * limitations under the License. */ package com.intellij.navigation + import com.intellij.ide.actions.GotoFileItemProvider import com.intellij.ide.util.gotoByName.ChooseByNamePopup +import com.intellij.ide.util.gotoByName.GotoClassModel2 import com.intellij.ide.util.gotoByName.GotoFileModel import com.intellij.openapi.application.ApplicationManager +import com.intellij.openapi.application.ReadAction +import com.intellij.openapi.module.ModuleUtilCore +import com.intellij.openapi.module.StdModuleTypes +import com.intellij.openapi.roots.ModuleRootModificationUtil import com.intellij.openapi.util.io.FileUtil +import com.intellij.testFramework.PsiTestUtil import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase import org.jetbrains.annotations.NotNull /** @@ -42,6 +49,21 @@ class ChooseByNameHddTest extends JavaCodeInsightFixtureTestCase { } } + public void "test prefer same-named classes visible in current module"() { + int moduleCount = 10 + def modules = (0..moduleCount-1).collect { + PsiTestUtil.addModule(project, StdModuleTypes.JAVA, "mod$it", myFixture.tempDirFixture.findOrCreateDir("mod$it")) + } + ModuleRootModificationUtil.addDependency(myFixture.module, modules[2]) + (0..moduleCount-1).each { myFixture.addFileToProject("mod$it/Foo.java", "class Foo {}") } + + def place = myFixture.addClass("class A {}") + def popup = ReadAction.compute { ChooseByNamePopup.createPopup(project, new GotoClassModel2(project), place) } + def resultModules = ChooseByNameTest.calcPopupElements(popup, 'Foo').collect { ModuleUtilCore.findModuleForPsiElement(it).name } + assert resultModules[0] == 'mod2' + popup.close(false) + } + @Override protected boolean runInDispatchThread() { return false diff --git a/java/java-tests/testSrc/com/intellij/refactoring/ChangeSignatureGestureTest.java b/java/java-tests/testSrc/com/intellij/refactoring/ChangeSignatureGestureTest.java index f4647486699d..c4dc509264e6 100644 --- a/java/java-tests/testSrc/com/intellij/refactoring/ChangeSignatureGestureTest.java +++ b/java/java-tests/testSrc/com/intellij/refactoring/ChangeSignatureGestureTest.java @@ -112,6 +112,7 @@ public class ChangeSignatureGestureTest extends LightCodeInsightFixtureTestCase public void testAddParamChangeReturnType() { doTest(() -> { myFixture.type("int param"); + PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); CaretModel model = myFixture.getEditor().getCaretModel(); PsiElement element = myFixture.getElementAtCaret(); PsiMethod method = PsiTreeUtil.getParentOfType(element, PsiMethod.class, false); diff --git a/platform/built-in-server/src/org/jetbrains/ide/RestService.java b/platform/built-in-server/src/org/jetbrains/ide/RestService.java index bae7bc59c24d..1afdbc1bacd7 100644 --- a/platform/built-in-server/src/org/jetbrains/ide/RestService.java +++ b/platform/built-in-server/src/org/jetbrains/ide/RestService.java @@ -26,7 +26,6 @@ import com.google.gson.stream.JsonReader; import com.google.gson.stream.JsonWriter; import com.google.gson.stream.MalformedJsonException; import com.intellij.ide.IdeBundle; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.project.ProjectManager; @@ -50,6 +49,7 @@ import io.netty.channel.ChannelHandlerContext; import io.netty.handler.codec.http.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.builtInWebServer.BuiltInWebServerKt; import org.jetbrains.io.NettyKt; import org.jetbrains.io.Responses; @@ -178,6 +178,10 @@ public abstract class RestService extends HttpRequestHandler { // e.g. upsource trust to configured host protected boolean isHostTrusted(@NotNull FullHttpRequest request) throws InterruptedException, InvocationTargetException { + if (BuiltInWebServerKt.isSignedRequest(request)) { + return true; + } + String referrer = NettyKt.getOrigin(request); if (referrer == null) { referrer = NettyKt.getReferrer(request); @@ -199,8 +203,6 @@ public abstract class RestService extends HttpRequestHandler { else { isTrusted.set(trustedOrigins.getIfPresent(host)); } - } else if (ApplicationManager.getApplication().isUnitTestMode()) { - isTrusted.set(Boolean.TRUE); // make the tests pass } if (isTrusted.isNull()) { diff --git a/platform/built-in-server/testSrc/RestApiTest.kt b/platform/built-in-server/testSrc/RestApiTest.kt index 8b01e8431c32..4839893924c3 100644 --- a/platform/built-in-server/testSrc/RestApiTest.kt +++ b/platform/built-in-server/testSrc/RestApiTest.kt @@ -64,9 +64,11 @@ internal class RestApiTest : BuiltInServerTestCase() { val column = manager.annotation?.column ?: -1 var connection = URL("$serviceUrl?file=${manager.filePath ?: ""}&line=$line&column=$column").openConnection() as HttpURLConnection + BuiltInServerManager.getInstance().configureRequestToWebServer(connection) assertThat(HttpResponseStatus.valueOf(connection.responseCode)).isEqualTo(expectedStatus) connection = URL("$serviceUrl").openConnection() as HttpURLConnection + BuiltInServerManager.getInstance().configureRequestToWebServer(connection) connection.requestMethod = "POST" connection.doOutput = true JsonWriter(connection.outputStream.bufferedWriter()).use { diff --git a/platform/core-impl/src/com/intellij/psi/impl/PsiCachedValue.java b/platform/core-impl/src/com/intellij/psi/impl/PsiCachedValue.java index ade9642d99f7..ec52235f1d67 100644 --- a/platform/core-impl/src/com/intellij/psi/impl/PsiCachedValue.java +++ b/platform/core-impl/src/com/intellij/psi/impl/PsiCachedValue.java @@ -54,7 +54,6 @@ public abstract class PsiCachedValue extends CachedValueBase { o instanceof PsiModificationTracker || o == PsiModificationTracker.MODIFICATION_COUNT || o == PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT || - o == PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT || o == PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT; } }); diff --git a/platform/editor-ui-ex/src/com/intellij/openapi/editor/ex/util/LayeredLexerEditorHighlighter.java b/platform/editor-ui-ex/src/com/intellij/openapi/editor/ex/util/LayeredLexerEditorHighlighter.java index 8af290897cd1..039dc7bd8e9d 100644 --- a/platform/editor-ui-ex/src/com/intellij/openapi/editor/ex/util/LayeredLexerEditorHighlighter.java +++ b/platform/editor-ui-ex/src/com/intellij/openapi/editor/ex/util/LayeredLexerEditorHighlighter.java @@ -153,14 +153,16 @@ public class LayeredLexerEditorHighlighter extends LexerEditorHighlighter { protected boolean updateLayers() { return false; } + @SuppressWarnings("NonSynchronizedMethodOverridesSynchronizedMethod") @Override public void documentChanged(DocumentEvent e) { // do NOT synchronize before updateLayers due to deadlock with PsiLock boolean changed = updateLayers(); + //noinspection SynchronizeOnThis synchronized (this) { if (changed) { - setText(e.getDocument().getImmutableCharSequence()); + super.setText(e.getDocument().getImmutableCharSequence()); } else { super.documentChanged(e); @@ -174,11 +176,14 @@ public class LayeredLexerEditorHighlighter extends LexerEditorHighlighter { // do NOT synchronize before updateLayers due to deadlock with PsiLock final boolean changed = updateLayers(); + //noinspection SynchronizeOnThis synchronized (this) { if (changed) { - CharSequence text = myText; - myText = null; - setText(text); + Document document = getDocument(); + if (document != null) { + myText = null; + super.setText(document.getImmutableCharSequence()); + } } return new LayeredHighlighterIteratorImpl(startOffset); } diff --git a/platform/lang-api/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithRangeAdjuster.java b/platform/lang-api/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithRangeAdjuster.java index b4e2fb4c1932..7f2d141e3c06 100644 --- a/platform/lang-api/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithRangeAdjuster.java +++ b/platform/lang-api/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithRangeAdjuster.java @@ -28,4 +28,7 @@ public interface SurroundWithRangeAdjuster { ExtensionPointName EP_NAME = ExtensionPointName.create("com.intellij.codeInsight.surroundWithRangeAdjuster"); @Nullable TextRange adjustSurroundWithRange(PsiFile file, TextRange selectedRange); + @Nullable default TextRange adjustSurroundWithRange(PsiFile file, TextRange selectedRange, boolean hasSelection) { + return adjustSurroundWithRange(file, selectedRange); + } } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/TargetElementUtil.java b/platform/lang-impl/src/com/intellij/codeInsight/TargetElementUtil.java index ff809a603de0..99debea9c8d3 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/TargetElementUtil.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/TargetElementUtil.java @@ -140,18 +140,7 @@ public class TargetElementUtil extends TargetElementUtilBase { private static PsiFile getFile(Project project, Document document) { PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(document); - - if (file != null) { - if (ApplicationManager.getApplication().isDispatchThread()) { - PsiDocumentManager.getInstance(project).commitAllDocuments(); - } - - if (file instanceof PsiCompiledFile) { - file = ((PsiCompiledFile)file).getDecompiledPsiFile(); - } - } - - return file; + return file instanceof PsiCompiledFile ? ((PsiCompiledFile)file).getDecompiledPsiFile() : file; } /** diff --git a/platform/lang-impl/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithHandler.java b/platform/lang-impl/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithHandler.java index bc4326d7c35d..9fd3d14a7d61 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithHandler.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/generation/surroundWith/SurroundWithHandler.java @@ -94,7 +94,8 @@ public class SurroundWithHandler implements CodeInsightActionHandler { @Nullable public static List buildSurroundActions(final Project project, final Editor editor, PsiFile file, @Nullable Surrounder surrounder){ SelectionModel selectionModel = editor.getSelectionModel(); - if (!selectionModel.hasSelection()) { + boolean hasSelection = selectionModel.hasSelection(); + if (!hasSelection) { selectionModel.selectLineAtCaret(); } int startOffset = selectionModel.getSelectionStart(); @@ -109,7 +110,7 @@ public class SurroundWithHandler implements CodeInsightActionHandler { TextRange textRange = new TextRange(startOffset, endOffset); for(SurroundWithRangeAdjuster adjuster: Extensions.getExtensions(SurroundWithRangeAdjuster.EP_NAME)) { - textRange = adjuster.adjustSurroundWithRange(file, textRange); + textRange = adjuster.adjustSurroundWithRange(file, textRange, hasSelection); if (textRange == null) return null; } startOffset = textRange.getStartOffset(); diff --git a/platform/lang-impl/src/com/intellij/codeInsight/highlighting/TemplateLanguageErrorFilter.java b/platform/lang-impl/src/com/intellij/codeInsight/highlighting/TemplateLanguageErrorFilter.java index 90545941cbc4..a5f4926e0e26 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/highlighting/TemplateLanguageErrorFilter.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/highlighting/TemplateLanguageErrorFilter.java @@ -106,7 +106,7 @@ public abstract class TemplateLanguageErrorFilter extends HighlightErrorFilter { protected boolean isKnownSubLanguage(@NotNull final Language language) { for (Language knownLanguage : knownLanguageSet) { - if (language.is(knownLanguage)) { + if (language.is(knownLanguage) || knownLanguage.getDialects().contains(language)) { return true; } } diff --git a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java index 707030cce5d8..f2391436e432 100644 --- a/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java +++ b/platform/lang-impl/src/com/intellij/codeInsight/hint/ParameterInfoComponent.java @@ -55,7 +55,8 @@ public class ParameterInfoComponent extends JPanel { private final Font NORMAL_FONT; private final Font BOLD_FONT; - private static final Border BACKGROUND_BORDER = BorderFactory.createLineBorder(BACKGROUND_COLOR); + private static final Border LAST_ITEM_BORDER = BorderFactory.createEmptyBorder(); + private static final Border BOTTOM_BORDER = new SideBorder(new JBColor(JBColor.LIGHT_GRAY, Gray._90), SideBorder.BOTTOM); protected int myWidthLimit = 500; @@ -166,14 +167,14 @@ public class ParameterInfoComponent extends JPanel { Color background) { final String resultedText = myPanels[i].setup(text, myEscapeFunction, highlightStartOffset, highlightEndOffset, isDisabled, strikeout, isDisabledBeforeHighlight, background); - myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : new SideBorder(new JBColor(JBColor.LIGHT_GRAY, Gray._90), SideBorder.BOTTOM)); + myPanels[i].setBorder(isLastParameterOwner() ? LAST_ITEM_BORDER : BOTTOM_BORDER); return resultedText; } @Override public String setupUIComponentPresentation(final String[] texts, final EnumSet[] flags, final Color background) { final String resultedText = myPanels[i].setup(texts, myEscapeFunction, flags, background); - myPanels[i].setBorder(isLastParameterOwner() ? BACKGROUND_BORDER : new SideBorder(new JBColor(JBColor.LIGHT_GRAY, Gray._90), SideBorder.BOTTOM)); + myPanels[i].setBorder(isLastParameterOwner() ? LAST_ITEM_BORDER : BOTTOM_BORDER); return resultedText; } diff --git a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java index 3270612c3a82..3666be983e23 100644 --- a/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java +++ b/platform/lang-impl/src/com/intellij/codeInspection/LossyEncodingInspection.java @@ -14,12 +14,6 @@ * limitations under the License. */ -/* - * Created by IntelliJ IDEA. - * User: cdr - * Date: Aug 6, 2007 - * Time: 3:09:55 PM - */ package com.intellij.codeInspection; import com.intellij.ide.DataManager; @@ -38,7 +32,6 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.ui.popup.ListPopup; import com.intellij.openapi.util.TextRange; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.vfs.CharsetToolkit; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.encoding.ChangeFileEncodingAction; import com.intellij.openapi.vfs.encoding.EncodingUtil; @@ -104,7 +97,7 @@ public class LossyEncodingInspection extends LocalInspectionTool { // no sense in checking transparently decoded file: all characters there are already safely encoded if (charset instanceof Native2AsciiCharset) return null; - List descriptors = new SmartList(); + List descriptors = new SmartList<>(); boolean ok = checkFileLoadedInWrongEncoding(file, manager, isOnTheFly, virtualFile, charset, descriptors); if (ok) { checkIfCharactersWillBeLostAfterSave(file, manager, isOnTheFly, text, charset, descriptors); @@ -173,11 +166,11 @@ public class LossyEncodingInspection extends LocalInspectionTool { @NotNull List descriptors) { int errorCount = 0; int start = -1; + CharBuffer buffer = CharBuffer.wrap(text); // temp buffer for encoding/decoding back a char or a surrogate pair. for (int i = 0; i <= text.length(); i++) { char c = i >= text.length() ? 0 : text.charAt(i); - char next = i + 1 >= text.length() ? 0 : text.charAt(i + 1); - char prev = i == 0 ? 0 : text.charAt(i - 1); - if (i == text.length() || isRepresentable(c, next, prev, charset)) { + int end = Character.isHighSurrogate(c) && i { - for (GlobalInspectionContextExtension extension : myExtensions.values()) { - try { - extension.performPostRunActivities(needRepeatSearchRequest, this); - } - catch (ProcessCanceledException | IndexNotReadyException e) { - throw e; - } - catch (Throwable e) { - LOG.error(e); - } + for (GlobalInspectionContextExtension extension : myExtensions.values()) { + try { + extension.performPostRunActivities(needRepeatSearchRequest, this); } - }); + catch (ProcessCanceledException | IndexNotReadyException e) { + throw e; + } + catch (Throwable e) { + LOG.error(e); + } + } if (!ApplicationManager.getApplication().isUnitTestMode()) { if (myView == null && !ReadAction.compute(() -> InspectionResultsView.hasProblems(globalTools, this, createContentProvider())).booleanValue()) { return; diff --git a/platform/lang-impl/src/com/intellij/execution/console/LanguageConsoleBuilder.java b/platform/lang-impl/src/com/intellij/execution/console/LanguageConsoleBuilder.java index fae5bea796ec..b09a88f42329 100644 --- a/platform/lang-impl/src/com/intellij/execution/console/LanguageConsoleBuilder.java +++ b/platform/lang-impl/src/com/intellij/execution/console/LanguageConsoleBuilder.java @@ -178,7 +178,14 @@ public final class LanguageConsoleBuilder { @NotNull public LanguageConsoleView build(@NotNull Project project, @NotNull Language language) { - GutteredLanguageConsole consoleView = new GutteredLanguageConsole(new MyHelper(project, language.getDisplayName() + " Console", language, psiFileFactory), gutterContentProvider); + return build(project, language, null); + } + + @NotNull + public LanguageConsoleView build(@NotNull Project project, @NotNull Language language, @Nullable VirtualFile virtualFileToReuse) { + final VirtualFile virtualFile = + virtualFileToReuse != null ? virtualFileToReuse : new LightVirtualFile(language.getDisplayName() + " Console", language, ""); + GutteredLanguageConsole consoleView = new GutteredLanguageConsole(new MyHelper(project, virtualFile, psiFileFactory), gutterContentProvider); if (oneLineInput) { consoleView.getConsoleEditor().setOneLineMode(true); } @@ -204,8 +211,10 @@ public final class LanguageConsoleBuilder { GutteredLanguageConsole console; - public MyHelper(@NotNull Project project, @NotNull String title, @NotNull Language language, @Nullable PairFunction psiFileFactory) { - super(project, new LightVirtualFile(title, language, "")); + public MyHelper(@NotNull Project project, + @NotNull VirtualFile virtualFile, + @Nullable PairFunction psiFileFactory) { + super(project, virtualFile); this.psiFileFactory = psiFileFactory; } diff --git a/platform/lang-impl/src/com/intellij/psi/util/proximity/InResolveScopeWeigher.java b/platform/lang-impl/src/com/intellij/psi/util/proximity/InResolveScopeWeigher.java new file mode 100644 index 000000000000..10e3152387b2 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/psi/util/proximity/InResolveScopeWeigher.java @@ -0,0 +1,41 @@ +/* + * Copyright 2000-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.psi.util.proximity; + +import com.intellij.openapi.util.NotNullLazyKey; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.PsiElement; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.util.ProximityLocation; +import com.intellij.psi.util.PsiUtilCore; +import org.jetbrains.annotations.NotNull; + +/** + * @author peter +*/ +public class InResolveScopeWeigher extends ProximityWeigher { + private static final NotNullLazyKey PLACE_SCOPE = NotNullLazyKey.create("placeScope", location -> { + PsiElement position = location.getPosition(); + return position == null ? GlobalSearchScope.EMPTY_SCOPE : position.getResolveScope(); + }); + + + @Override + public Comparable weigh(@NotNull final PsiElement element, @NotNull final ProximityLocation location) { + VirtualFile elementFile = PsiUtilCore.getVirtualFile(element); + return elementFile != null && PLACE_SCOPE.getValue(location).contains(elementFile); + } +} diff --git a/platform/lang-impl/src/com/intellij/refactoring/copy/CopyFilesOrDirectoriesDialog.java b/platform/lang-impl/src/com/intellij/refactoring/copy/CopyFilesOrDirectoriesDialog.java index 5ae5a67a0590..324398d16e85 100644 --- a/platform/lang-impl/src/com/intellij/refactoring/copy/CopyFilesOrDirectoriesDialog.java +++ b/platform/lang-impl/src/com/intellij/refactoring/copy/CopyFilesOrDirectoriesDialog.java @@ -81,6 +81,8 @@ public class CopyFilesOrDirectoriesDialog extends DialogWrapper { private JLabel myInformationLabel; private TextFieldWithHistoryWithBrowseButton myTargetDirectoryField; private JCheckBox myOpenFilesInEditor = createOpenInEditorCB(); + private boolean myUnknownFileType = false; + private JTextField myNewNameField; private final PsiElement[] myElements; private final Project myProject; @@ -248,7 +250,9 @@ public class CopyFilesOrDirectoriesDialog extends DialogWrapper { } public boolean openInEditor() { - return myOpenFilesInEditor.isSelected(); + return myOpenFilesInEditor.isVisible() && + myOpenFilesInEditor.isSelected() && + !myUnknownFileType; } @Override @@ -266,12 +270,16 @@ public class CopyFilesOrDirectoriesDialog extends DialogWrapper { return; } - if (myFileCopy && FileTypeChooser.getKnownFileTypeOrAssociate(myTargetDirectory.getVirtualFile(), newName, myProject) == null) { - return; + if (myFileCopy) { + if (FileTypeChooser.getKnownFileTypeOrAssociate(myTargetDirectory.getVirtualFile(), newName, myProject) == null) { + myUnknownFileType = true; + } } } - saveOpenInEditorState(myOpenFilesInEditor.isSelected()); + if (myOpenFilesInEditor.isVisible()) { + saveOpenInEditorState(myOpenFilesInEditor.isSelected()); + } if (myShowDirectoryField) { final String targetDirectoryName = myTargetDirectoryField.getChildComponent().getText(); diff --git a/platform/lang-impl/src/com/intellij/refactoring/lang/ExtractIncludeFileBase.java b/platform/lang-impl/src/com/intellij/refactoring/lang/ExtractIncludeFileBase.java index ebe4495b9268..ea96f42cb9e7 100644 --- a/platform/lang-impl/src/com/intellij/refactoring/lang/ExtractIncludeFileBase.java +++ b/platform/lang-impl/src/com/intellij/refactoring/lang/ExtractIncludeFileBase.java @@ -51,6 +51,7 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.annotations.TestOnly; import java.util.ArrayList; import java.util.List; @@ -180,7 +181,16 @@ public abstract class ExtractIncludeFileBase implements Re @Override public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file, DataContext dataContext) { - myIncludingFile = file; + try { + myIncludingFile = file; + doInvoke(project, editor, file); + } + finally { + myIncludingFile = null; + } + } + + protected void doInvoke(@NotNull Project project, Editor editor, PsiFile file) { if (!editor.getSelectionModel().hasSelection()) { String message = RefactoringBundle.getCannotRefactorMessage(RefactoringBundle.message("no.selection")); CommonRefactoringUtil.showErrorHint(project, editor, message, getRefactoringName(), HELP_ID); @@ -250,6 +260,8 @@ public abstract class ExtractIncludeFileBase implements Re return extractFileType.getDefaultExtension(); } + @Deprecated + @TestOnly public boolean isValidRange(final T firstToExtract, final T lastToExtract) { return verifyChildRange(firstToExtract, lastToExtract); } diff --git a/platform/platform-api/src/com/intellij/openapi/keymap/KeymapUtil.java b/platform/platform-api/src/com/intellij/openapi/keymap/KeymapUtil.java index d855498133e0..4f7cf9ca0c85 100644 --- a/platform/platform-api/src/com/intellij/openapi/keymap/KeymapUtil.java +++ b/platform/platform-api/src/com/intellij/openapi/keymap/KeymapUtil.java @@ -76,12 +76,9 @@ public class KeymapUtil { if (!acceleratorText.isEmpty()) { s += ", " + acceleratorText; } - } else if (shortcut instanceof PressureShortcut) { - s += shortcut.toString(); } else if (shortcut instanceof MouseShortcut) { - MouseShortcut mouseShortcut = (MouseShortcut)shortcut; - s = getMouseShortcutText(mouseShortcut.getButton(), mouseShortcut.getModifiers(), mouseShortcut.getClickCount()); + s = getMouseShortcutText((MouseShortcut)shortcut); } else if (shortcut instanceof KeyboardModifierGestureShortcut) { final KeyboardModifierGestureShortcut gestureShortcut = (KeyboardModifierGestureShortcut)shortcut; @@ -106,6 +103,11 @@ public class KeymapUtil { } } + public static String getMouseShortcutText(@NotNull MouseShortcut shortcut) { + if (shortcut instanceof PressureShortcut) return shortcut.toString(); + return getMouseShortcutText(shortcut.getButton(), shortcut.getModifiers(), shortcut.getClickCount()); + } + /** * @param button target mouse button * @param modifiers modifiers used within the target click diff --git a/platform/platform-api/src/com/intellij/openapi/ui/LoadingDecorator.java b/platform/platform-api/src/com/intellij/openapi/ui/LoadingDecorator.java index 4bf2a4351e85..3127ab3e8417 100644 --- a/platform/platform-api/src/com/intellij/openapi/ui/LoadingDecorator.java +++ b/platform/platform-api/src/com/intellij/openapi/ui/LoadingDecorator.java @@ -113,7 +113,7 @@ public class LoadingDecorator { } } - private void _startLoading(final boolean takeSnapshot) { + protected void _startLoading(final boolean takeSnapshot) { myLoadingLayer.setVisible(true, takeSnapshot); } diff --git a/platform/platform-impl/src/com/intellij/ide/IdeEventQueue.java b/platform/platform-impl/src/com/intellij/ide/IdeEventQueue.java index aa75d5ffc1b7..1fce159d8d2b 100644 --- a/platform/platform-impl/src/com/intellij/ide/IdeEventQueue.java +++ b/platform/platform-impl/src/com/intellij/ide/IdeEventQueue.java @@ -138,6 +138,7 @@ public class IdeEventQueue extends EventQueue { private boolean myKeyboardBusy; private boolean myDispatchingFocusEvent; + private boolean myWinMetaPressed; private int myInputMethodLock; @@ -370,6 +371,9 @@ public class IdeEventQueue extends EventQueue { e = fixNonEnglishKeyboardLayouts(e); e = mapEvent(e); + if (Registry.is("keymap.windows.as.meta")) { + e = mapMetaState(e); + } boolean wasInputEvent = myIsInInputEvent; myIsInInputEvent = e instanceof InputEvent || e instanceof InputMethodEvent || e instanceof WindowEvent || e instanceof ActionEvent; @@ -530,6 +534,38 @@ public class IdeEventQueue extends EventQueue { return e; } + private AWTEvent mapMetaState(AWTEvent e) { + if (myWinMetaPressed) { + Application app = ApplicationManager.getApplication(); + if (app == null || !app.isActive()) { + myWinMetaPressed = false; + return e; + } + } + + if (e instanceof KeyEvent) { + KeyEvent ke = (KeyEvent)e; + if (ke.getKeyCode() == KeyEvent.VK_WINDOWS) { + if (ke.getID() == KeyEvent.KEY_PRESSED) myWinMetaPressed = true; + if (ke.getID() == KeyEvent.KEY_RELEASED) myWinMetaPressed = false; + return new KeyEvent(ke.getComponent(), ke.getID(), ke.getWhen(), ke.getModifiers(), KeyEvent.VK_META, ke.getKeyChar(), + ke.getKeyLocation()); + } + if (myWinMetaPressed) { + return new KeyEvent(ke.getComponent(), ke.getID(), ke.getWhen(), ke.getModifiers() | InputEvent.META_MASK, ke.getKeyCode(), + ke.getKeyChar(), ke.getKeyLocation()); + } + } + + if (myWinMetaPressed && e instanceof MouseEvent && ((MouseEvent)e).getButton() != 0) { + MouseEvent me = (MouseEvent)e; + return new MouseEvent(me.getComponent(), me.getID(), me.getWhen(), me.getModifiers() | InputEvent.META_MASK, me.getX(), me.getY(), + me.getClickCount(), me.isPopupTrigger(), me.getButton()); + } + + return e; + } + public void _dispatchEvent(@NotNull AWTEvent e, boolean typeAheadFlushing) { if (e.getID() == MouseEvent.MOUSE_DRAGGED) { DnDManagerImpl dndManager = (DnDManagerImpl)DnDManager.getInstance(); diff --git a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/AsyncEditorLoader.java b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/AsyncEditorLoader.java index 64d51d6c1cbd..0ea75814ce63 100644 --- a/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/AsyncEditorLoader.java +++ b/platform/platform-impl/src/com/intellij/openapi/fileEditor/impl/text/AsyncEditorLoader.java @@ -91,7 +91,9 @@ public class AsyncEditorLoader { @Override public void onCanceled(@NotNull ProgressIndicator indicator) { - scheduleBackgroundLoading(false); + if (!Disposer.isDisposed(myTextEditor) && !myProject.isDisposed()) { + scheduleBackgroundLoading(false); + } } }; diff --git a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutDialog.java b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutDialog.java index cbd488c6eea1..9c8dbb6d7ace 100644 --- a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutDialog.java +++ b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutDialog.java @@ -17,17 +17,19 @@ package com.intellij.openapi.keymap.impl.ui; import com.intellij.icons.AllIcons; import com.intellij.openapi.actionSystem.MouseShortcut; -import com.intellij.openapi.actionSystem.PressureShortcut; import com.intellij.openapi.keymap.KeyMapBundle; import com.intellij.openapi.keymap.Keymap; import com.intellij.openapi.keymap.KeymapUtil; import com.intellij.util.ui.JBUI; import com.intellij.util.ui.UIUtil; -import javax.swing.*; -import java.awt.*; +import java.awt.BorderLayout; +import java.awt.Component; import java.util.Arrays; import java.util.Collection; +import javax.swing.BorderFactory; +import javax.swing.JLabel; +import javax.swing.SwingConstants; /** * @author Vladimir Kondratyev @@ -66,16 +68,9 @@ final class MouseShortcutDialog extends ShortcutDialog { myText.setForeground(MouseShortcutPanel.FOREGROUND); myText.setText(KeyMapBundle.message("dialog.mouse.pad.default.text")); } - else if (shortcut instanceof PressureShortcut) { - myText.setForeground(UIUtil.getLabelForeground()); - myText.setText(KeyMapBundle.message("dialog.mouse.pad.shortcut.text", shortcut.toString())); - } else { myText.setForeground(UIUtil.getLabelForeground()); - myText.setText(KeyMapBundle.message("dialog.mouse.pad.shortcut.text", KeymapUtil.getMouseShortcutText( - shortcut.getButton(), - shortcut.getModifiers(), - shortcut.getClickCount()))); + myText.setText(KeyMapBundle.message("dialog.mouse.pad.shortcut.text", KeymapUtil.getMouseShortcutText(shortcut))); } } diff --git a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutPanel.java b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutPanel.java index 9562d96338d4..25d3efa6ee41 100644 --- a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutPanel.java +++ b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/MouseShortcutPanel.java @@ -16,14 +16,12 @@ package com.intellij.openapi.keymap.impl.ui; import com.intellij.openapi.actionSystem.MouseShortcut; -import com.intellij.openapi.actionSystem.PressureShortcut; -import com.intellij.openapi.actionSystem.Shortcut; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.registry.Registry; import com.intellij.ui.JBColor; import com.intellij.ui.mac.MacGestureSupportForMouseShortcutPanel; -import java.awt.*; +import java.awt.BorderLayout; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseWheelEvent; @@ -37,34 +35,33 @@ public final class MouseShortcutPanel extends ShortcutPanel { static final JBColor BORDER = new JBColor(0xDEDEDE, 0x383B3D); private final int myClickCount; - private boolean myPressureTouch = false; private MouseShortcut myMouseShortcut = null; private final MouseAdapter myMouseListener = new MouseAdapter() { @Override public void mouseWheelMoved(MouseWheelEvent event) { - mousePressed(event); + setShortcutIfNeeded(toMouseShortcut(event)); } @Override public void mousePressed(MouseEvent event) { - myPressureTouch = false; + myMouseShortcut = toMouseShortcut(event); + } + + private MouseShortcut toMouseShortcut(MouseEvent event) { int button = MouseShortcut.getButton(event); int clickCount = event instanceof MouseWheelEvent ? 1 : event.getClickCount(); if (0 <= button && clickCount <= myClickCount) { int modifiers = event.getModifiersEx(); - myMouseShortcut = new MouseShortcut(button, modifiers, clickCount); + return new MouseShortcut(button, modifiers, clickCount); } + return null; } @Override public void mouseReleased(MouseEvent event) { event.consume(); - - if (myPressureTouch) { - return; - } - setShortcut(myMouseShortcut); + setShortcutIfNeeded(myMouseShortcut); } }; @@ -74,28 +71,20 @@ public final class MouseShortcutPanel extends ShortcutPanel { addMouseListener(myMouseListener); addMouseWheelListener(myMouseListener); if (SystemInfo.isJavaVersionAtLeast("1.8") && SystemInfo.isMacIntel64 && SystemInfo.isJetbrainsJvm && Registry.is("ide.mac.forceTouch")) { - new MacGestureSupportForMouseShortcutPanel(this, new Runnable() { - @Override - public void run() { - myPressureTouch = true; - } - }); + new MacGestureSupportForMouseShortcutPanel(this, () -> myMouseShortcut = null); } setBackground(BACKGROUND); setOpaque(true); } - void setShortcut(MouseShortcut shortcut) { - Shortcut old = getShortcut(); + public void setShortcut(MouseShortcut shortcut) { + MouseShortcut old = getShortcut(); if (old != null || shortcut != null) { super.setShortcut(shortcut); } } - public void setShortcut(PressureShortcut shortcut) { - Shortcut old = getShortcut(); - if (old != null || shortcut != null) { - super.setShortcut(shortcut); - } + private void setShortcutIfNeeded(MouseShortcut shortcut) { + if (shortcut != null) setShortcut(shortcut); } } diff --git a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/ShortcutFilteringPanel.java b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/ShortcutFilteringPanel.java index e0f54b377d1c..e2e446792f25 100644 --- a/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/ShortcutFilteringPanel.java +++ b/platform/platform-impl/src/com/intellij/openapi/keymap/impl/ui/ShortcutFilteringPanel.java @@ -19,7 +19,6 @@ import com.intellij.icons.AllIcons; import com.intellij.ide.IdeEventQueue; import com.intellij.openapi.actionSystem.KeyboardShortcut; import com.intellij.openapi.actionSystem.MouseShortcut; -import com.intellij.openapi.actionSystem.PressureShortcut; import com.intellij.openapi.actionSystem.Shortcut; import com.intellij.openapi.keymap.KeyMapBundle; import com.intellij.openapi.keymap.KeymapUtil; @@ -68,27 +67,15 @@ final class ShortcutFilteringPanel extends JPanel { if (ShortcutFilteringPanel.this == event.getSource()) { if (value instanceof KeyboardShortcut) { KeyboardShortcut shortcut = (KeyboardShortcut)value; - myMousePanel.setShortcut((MouseShortcut)null); + myMousePanel.setShortcut(null); myKeyboardPanel.setShortcut(shortcut); if (null != shortcut.getSecondKeyStroke()) { myKeyboardPanel.mySecondStrokeEnable.setSelected(true); } } - else if (value instanceof PressureShortcut) { - String text = "Power Touch"; - MouseShortcut shortcut = (PressureShortcut)value; - myMousePanel.setShortcut(shortcut); - myKeyboardPanel.setShortcut(null); - myKeyboardPanel.myFirstStroke.setText(text); - myKeyboardPanel.mySecondStroke.setText(null); - myKeyboardPanel.mySecondStroke.setEnabled(false); - } else { MouseShortcut shortcut = value instanceof MouseShortcut ? (MouseShortcut)value : null; - String text = shortcut == null ? null : KeymapUtil.getMouseShortcutText( - shortcut.getButton(), - shortcut.getModifiers(), - shortcut.getClickCount()); + String text = shortcut == null ? null : KeymapUtil.getMouseShortcutText(shortcut); myMousePanel.setShortcut(shortcut); myKeyboardPanel.setShortcut(null); myKeyboardPanel.myFirstStroke.setText(text); diff --git a/platform/platform-impl/src/com/intellij/openapi/progress/BackgroundTaskQueue.java b/platform/platform-impl/src/com/intellij/openapi/progress/BackgroundTaskQueue.java index b1a18fad2391..dfa0e2302114 100644 --- a/platform/platform-impl/src/com/intellij/openapi/progress/BackgroundTaskQueue.java +++ b/platform/platform-impl/src/com/intellij/openapi/progress/BackgroundTaskQueue.java @@ -17,6 +17,7 @@ package com.intellij.openapi.progress; import com.intellij.openapi.Disposable; +import com.intellij.openapi.application.Application; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ModalityState; import com.intellij.openapi.progress.impl.BackgroundableProcessIndicator; @@ -40,7 +41,8 @@ public class BackgroundTaskQueue { @NotNull private final String myTitle; @NotNull private final QueueProcessor myProcessor; - private boolean myForceAsyncInTests = false; + @NotNull private final Object TEST_TASK_LOCK = new Object(); + private volatile boolean myForceAsyncInTests = false; public BackgroundTaskQueue(@Nullable Project project, @NotNull String title) { myTitle = title; @@ -49,8 +51,20 @@ public class BackgroundTaskQueue { myProcessor = new QueueProcessor((data, continuation) -> { Task.Backgroundable task = data.task; + ProgressIndicator indicator = data.indicator; + if (indicator == null) { + if (ApplicationManager.getApplication().isHeadlessEnvironment()) { + indicator = new EmptyProgressIndicator(); + } + else { + // BackgroundableProcessIndicator should be created from EDT + indicator = new BackgroundableProcessIndicator(task); + } + } + ModalityState modalityState = data.modalityState; + if (modalityState == null) modalityState = ModalityState.NON_MODAL; if (StringUtil.isEmptyOrSpaces(task.getTitle())) { task.setTitle(myTitle); @@ -91,24 +105,21 @@ public class BackgroundTaskQueue { } public void run(@NotNull Task.Backgroundable task, @Nullable ModalityState modalityState, @Nullable ProgressIndicator indicator) { - if (modalityState == null) modalityState = ModalityState.NON_MODAL; - if (indicator == null) { - if (ApplicationManager.getApplication().isHeadlessEnvironment()) { - indicator = new EmptyProgressIndicator(); - } - else { - indicator = new BackgroundableProcessIndicator(task); - } + TaskData taskData = new TaskData(task, modalityState, indicator); + if (!myForceAsyncInTests && ApplicationManager.getApplication().isUnitTestMode()) { + runTaskInCurrentThread(taskData); + } + else { + myProcessor.add(taskData, modalityState); } - myProcessor.add(new TaskData(task, modalityState, indicator), modalityState); } private static class TaskData { @NotNull public final Task.Backgroundable task; - @NotNull public final ModalityState modalityState; - @NotNull public final ProgressIndicator indicator; + @Nullable public final ModalityState modalityState; + @Nullable public final ProgressIndicator indicator; - public TaskData(@NotNull Task.Backgroundable task, @NotNull ModalityState modalityState, @NotNull ProgressIndicator indicator) { + public TaskData(@NotNull Task.Backgroundable task, @Nullable ModalityState modalityState, @Nullable ProgressIndicator indicator) { this.task = task; this.modalityState = modalityState; this.indicator = indicator; @@ -117,7 +128,6 @@ public class BackgroundTaskQueue { @TestOnly public void setForceAsyncInTests(boolean value, @Nullable Disposable disposable) { - ApplicationManager.getApplication().assertIsDispatchThread(); myForceAsyncInTests = value; if (disposable != null) { Disposer.register(disposable, new Disposable() { @@ -128,4 +138,55 @@ public class BackgroundTaskQueue { }); } } + + private void runTaskInCurrentThread(@NotNull TaskData data) { + Task.Backgroundable task = data.task; + + ProgressIndicator indicator = data.indicator; + if (indicator == null) indicator = new EmptyProgressIndicator(); + + ModalityState modalityState = data.modalityState; + if (modalityState == null) modalityState = ModalityState.NON_MODAL; + + boolean processCanceled = false; + Exception exception = null; + try { + synchronized (TEST_TASK_LOCK) { + task.run(indicator); + } + } + catch (ProcessCanceledException e) { + processCanceled = true; + } + catch (Exception e) { + exception = e; + } + + final boolean finalCanceled = processCanceled || indicator.isCanceled(); + final Exception finalException = exception; + Runnable finishTask = () -> { + try { + if (finalException != null) { + task.onError(finalException); + } + else if (finalCanceled) { + task.onCancel(); + } + else { + task.onSuccess(); + } + } + finally { + task.onFinished(); + } + }; + + Application application = ApplicationManager.getApplication(); + if (application.isDispatchThread()) { + finishTask.run(); + } + else { + application.invokeLater(finishTask, modalityState); + } + } } diff --git a/platform/platform-impl/src/com/intellij/openapi/ui/impl/DialogWrapperPeerImpl.java b/platform/platform-impl/src/com/intellij/openapi/ui/impl/DialogWrapperPeerImpl.java index 9c3c823ef043..1beef226d657 100644 --- a/platform/platform-impl/src/com/intellij/openapi/ui/impl/DialogWrapperPeerImpl.java +++ b/platform/platform-impl/src/com/intellij/openapi/ui/impl/DialogWrapperPeerImpl.java @@ -479,6 +479,12 @@ public class DialogWrapperPeerImpl extends DialogWrapperPeer implements FocusTra } private class AnCancelAction extends AnAction implements DumbAware { + + @Override + public boolean startInTransaction() { + return false; + } + @Override public void update(AnActionEvent e) { Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowsPane.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowsPane.java index c3628e977c7a..9ef31f14ec31 100644 --- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowsPane.java +++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowsPane.java @@ -449,6 +449,10 @@ public final class ToolWindowsPane extends JBLayeredPane implements Disposable { return myBottomStripe.isVisible() ? myBottomStripe.getHeight() : 0; } + public boolean isBottomSideToolWindowsVisible() { + return getComponentAt(ToolWindowAnchor.BOTTOM) != null; + } + @Nullable Stripe getStripeFor(String id) { ToolWindow window = myManager.getToolWindow(id); diff --git a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/InfoAndProgressPanel.java b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/InfoAndProgressPanel.java index 905bfa71028e..abb92be25070 100644 --- a/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/InfoAndProgressPanel.java +++ b/platform/platform-impl/src/com/intellij/openapi/wm/impl/status/InfoAndProgressPanel.java @@ -37,6 +37,7 @@ import com.intellij.openapi.wm.IdeFrame; import com.intellij.openapi.wm.StatusBar; import com.intellij.openapi.wm.StatusBarWidget; import com.intellij.openapi.wm.ex.ProgressIndicatorEx; +import com.intellij.openapi.wm.impl.ToolWindowsPane; import com.intellij.ui.BalloonLayoutImpl; import com.intellij.ui.Gray; import com.intellij.ui.TabbedPaneWrapper; @@ -434,7 +435,7 @@ public class InfoAndProgressPanel extends JPanel implements CustomStatusBarWidge public RelativePoint recalculateLocation(Balloon object) { Component c = getAnchor(pane); int y = c.getHeight() - 45; - if (balloonLayout != null) { + if (balloonLayout != null && !isBottomSideToolWindowsVisible(pane)) { Component component = balloonLayout.getTopBalloonComponent(); if (component != null) { y = SwingUtilities.convertPoint(component, 0, -45, c).y; @@ -465,6 +466,11 @@ public class InfoAndProgressPanel extends JPanel implements CustomStatusBarWidge return ex == null ? pane : ex.getSplitters(); } + private static boolean isBottomSideToolWindowsVisible(@NotNull JRootPane parent) { + ToolWindowsPane pane = UIUtil.findComponentOfType(parent, ToolWindowsPane.class); + return pane != null && pane.isBottomSideToolWindowsVisible(); + } + public Couple setText(@Nullable final String text, @Nullable final String requestor) { if (StringUtil.isEmpty(text) && !Comparing.equal(requestor, myCurrentRequestor) && !EventLog.LOG_REQUESTOR.equals(requestor)) { return Couple.of(myInfoPanel.getText(), myCurrentRequestor); diff --git a/platform/platform-resources/src/DefaultColorSchemesManager.xml b/platform/platform-resources/src/DefaultColorSchemesManager.xml index 650fadd78416..da11490c7cff 100644 --- a/platform/platform-resources/src/DefaultColorSchemesManager.xml +++ b/platform/platform-resources/src/DefaultColorSchemesManager.xml @@ -752,12 +752,12 @@ @@ -1691,7 +1691,7 @@ diff --git a/platform/platform-resources/src/META-INF/LangExtensions.xml b/platform/platform-resources/src/META-INF/LangExtensions.xml index ecca468dad78..acce28ef4bca 100644 --- a/platform/platform-resources/src/META-INF/LangExtensions.xml +++ b/platform/platform-resources/src/META-INF/LangExtensions.xml @@ -523,8 +523,10 @@ order="after sameDirectory"/> - + submit = submit(map); futures.add(submit); } - Future waitFuture = myThreadPool.submit((Runnable)() -> { + Future waitFuture = myThreadPool.submit(() -> { try { while (ContainerUtil.find(futures, STILL_RUNNING) != null) { Thread.sleep(100); diff --git a/platform/structuralsearch/testSource/com/intellij/structuralsearch/StructuralSearchTest.java b/platform/structuralsearch/testSource/com/intellij/structuralsearch/StructuralSearchTest.java index bd83763792df..63fd488c6c07 100644 --- a/platform/structuralsearch/testSource/com/intellij/structuralsearch/StructuralSearchTest.java +++ b/platform/structuralsearch/testSource/com/intellij/structuralsearch/StructuralSearchTest.java @@ -3453,7 +3453,7 @@ public class StructuralSearchTest extends StructuralSearchTestCase { " final int var3;" + " }" + "}"; - assertEquals("parameters and local variables are not package local", 1, findMatchesCount(source, "@Modifier(\"packageLocal\") '_T '_a;")); + assertEquals("parameters and local variables are not package-private", 1, findMatchesCount(source, "@Modifier(\"packageLocal\") '_T '_a;")); assertEquals("any variable can be final", 3, findMatchesCount(source, "@Modifier(\"final\") '_T '_a;")); assertEquals("parameters and local variables are not instance fields", 1, findMatchesCount(source, "@Modifier(\"Instance\") '_T '_a;")); } diff --git a/platform/util/resources/misc/registry.properties b/platform/util/resources/misc/registry.properties index 3ee1f67a4f1c..5fa42afbeba4 100644 --- a/platform/util/resources/misc/registry.properties +++ b/platform/util/resources/misc/registry.properties @@ -280,6 +280,7 @@ find.search.in.project.files=true structureView.coalesceTime=500 keymap.show.alias.actions=false +keymap.windows.as.meta=true frameworks.download.libraries.server.url=http://pluginsrepo-test:8080 caches.indexerThreadsCount=-1 navBar.updateMergeTime=100 diff --git a/platform/util/src/com/intellij/execution/CommandLineWrapperUtil.java b/platform/util/src/com/intellij/execution/CommandLineWrapperUtil.java index a526ff0bb699..360b6812e760 100644 --- a/platform/util/src/com/intellij/execution/CommandLineWrapperUtil.java +++ b/platform/util/src/com/intellij/execution/CommandLineWrapperUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,10 +15,7 @@ */ package com.intellij.execution; -import com.intellij.openapi.util.Ref; import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import java.io.BufferedOutputStream; @@ -29,7 +26,6 @@ import java.util.List; import java.util.jar.Attributes; import java.util.jar.JarOutputStream; import java.util.jar.Manifest; -import java.util.zip.ZipOutputStream; public class CommandLineWrapperUtil { @NotNull @@ -38,40 +34,21 @@ public class CommandLineWrapperUtil { } @NotNull - public static File createClasspathJarFile(Manifest manifest, List pathList, final boolean notEscape) throws IOException { - final Attributes attributes = manifest.getMainAttributes(); - attributes.put(Attributes.Name.MANIFEST_VERSION, "1.0"); + @SuppressWarnings({"deprecation", "IOResourceOpenedButNotSafelyClosed"}) + public static File createClasspathJarFile(Manifest manifest, List pathList, boolean notEscape) throws IOException { + manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0"); - final Ref ex = new Ref(); - final String classPathAttribute = StringUtil.join(pathList, new Function() { - @Override - public String fun(String path) { - final File classpathElement = new File(path); - try { - return (notEscape ? classpathElement.toURL() : classpathElement.toURI().toURL()).toString(); - } - catch (IOException e) { - ex.set(e); - return null; - } - } - }, " "); - - final IOException thrownException = ex.get(); - if (thrownException != null) { - throw thrownException; + StringBuilder classPath = new StringBuilder(); + for (String path : pathList) { + if (classPath.length() > 0) classPath.append(' '); + File classpathElement = new File(path); + String url = (notEscape ? classpathElement.toURL() : classpathElement.toURI().toURL()).toString(); + classPath.append(url); } - attributes.put(Attributes.Name.CLASS_PATH, classPathAttribute); + manifest.getMainAttributes().put(Attributes.Name.CLASS_PATH, classPath.toString()); File jarFile = FileUtil.createTempFile("classpath", ".jar", true); - ZipOutputStream jarPlugin = null; - try { - BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(jarFile)); - jarPlugin = new JarOutputStream(out, manifest); - } - finally { - if (jarPlugin != null) jarPlugin.close(); - } + new JarOutputStream(new BufferedOutputStream(new FileOutputStream(jarFile)), manifest).close(); return jarFile; } -} +} \ No newline at end of file diff --git a/platform/util/src/com/intellij/util/io/BaseDataReader.java b/platform/util/src/com/intellij/util/io/BaseDataReader.java index 6f974b5d8ff7..677bf6479c08 100644 --- a/platform/util/src/com/intellij/util/io/BaseDataReader.java +++ b/platform/util/src/com/intellij/util/io/BaseDataReader.java @@ -68,6 +68,36 @@ public abstract class BaseDataReader { } } + /** + * Please don't override this method as the BseOSProcessProcessHandler assumes that it can be two reading modes: blocking and non-blocking. + * Implement {@link #readAvailableBlocking} and {@link #readAvailableNonBlocking} instead. + * + * + * If the process handler assumes that reader handles the blocking mode, while it doesn't, it will result into premature stream close. + * + * @return true in case any data was read + * @throws IOException if an exception during IO happened + */ + protected boolean readAvailable() throws IOException { + return mySleepingPolicy == SleepingPolicy.BLOCKING ? readAvailableBlocking() : readAvailableNonBlocking(); + } + + /** + * + * Non-blocking read returns the control back to the process handler when there is no data to read. + * + */ + protected boolean readAvailableNonBlocking() throws IOException { + throw new UnsupportedOperationException(); + } + + /** + * Reader in a blocking mode blocks on IO read operation until data is received. It exits the method only after stream is closed. + */ + protected boolean readAvailableBlocking() throws IOException { + throw new UnsupportedOperationException(); + } + @NotNull protected abstract Future executeOnPooledThread(@NotNull Runnable runnable); @@ -158,7 +188,6 @@ public abstract class BaseDataReader { } } - protected abstract boolean readAvailable() throws IOException; protected abstract void close() throws IOException; public void stop() { diff --git a/platform/util/src/com/intellij/util/io/BaseOutputReader.java b/platform/util/src/com/intellij/util/io/BaseOutputReader.java index 7d794301fc84..734d1b148cd9 100644 --- a/platform/util/src/com/intellij/util/io/BaseOutputReader.java +++ b/platform/util/src/com/intellij/util/io/BaseOutputReader.java @@ -178,11 +178,6 @@ public abstract class BaseOutputReader extends BaseDataReader { line.setLength(0); } - @Override - protected boolean readAvailable() throws IOException { - return mySleepingPolicy == SleepingPolicy.BLOCKING ? readAvailableBlocking() : readAvailableNonBlocking(); - } - @Override protected void close() throws IOException { myReader.close(); diff --git a/platform/util/src/com/intellij/util/io/BinaryOutputReader.java b/platform/util/src/com/intellij/util/io/BinaryOutputReader.java index e8e5bea20d40..1e61b91d0676 100644 --- a/platform/util/src/com/intellij/util/io/BinaryOutputReader.java +++ b/platform/util/src/com/intellij/util/io/BinaryOutputReader.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -33,16 +33,32 @@ public abstract class BinaryOutputReader extends BaseDataReader { } @Override - protected boolean readAvailable() throws IOException { + protected boolean readAvailableNonBlocking() throws IOException { byte[] buffer = myBuffer; - boolean read = false; - while (myStream.available() > 0) { - int n = myStream.read(buffer); - if (n <= 0) break; - read = true; - onBinaryAvailable(buffer, n); + int n; + while (myStream.available() > 0 && (n = myStream.read(buffer)) >= 0) { + if (n > 0) { + read = true; + onBinaryAvailable(buffer, n); + } + } + + return read; + } + + @Override + protected final boolean readAvailableBlocking() throws IOException { + byte[] buffer = myBuffer; + boolean read = false; + + int n; + while ((n = myStream.read(buffer)) >= 0) { + if (n > 0) { + read = true; + onBinaryAvailable(buffer, n); + } } return read; @@ -54,4 +70,4 @@ public abstract class BinaryOutputReader extends BaseDataReader { protected void close() throws IOException { myStream.close(); } -} +} \ No newline at end of file diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/MainFrame.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/MainFrame.java index 0f49a6540fa3..3b70b4469c40 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/MainFrame.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/MainFrame.java @@ -20,7 +20,6 @@ import com.intellij.ui.components.panels.Wrapper; import com.intellij.util.ArrayUtil; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; -import com.intellij.util.ui.AsyncProcessIcon; import com.intellij.util.ui.JBUI; import com.intellij.util.ui.table.ComponentsListFocusTraversalPolicy; import com.intellij.vcs.CommittedChangeListForRevision; @@ -114,7 +113,13 @@ public class MainFrame extends JPanel implements DataProvider, Disposable { toolbarsAndTable.add(myDetailsSplitter, BorderLayout.CENTER); ProgressStripe progressStripe = - new ProgressStripe(toolbarsAndTable, toolbars, this, ProgressWindow.DEFAULT_PROGRESS_DIALOG_POSTPONE_TIME_MILLIS); + new ProgressStripe(toolbarsAndTable, toolbars, this, ProgressWindow.DEFAULT_PROGRESS_DIALOG_POSTPONE_TIME_MILLIS) { + @Override + public void updateUI() { + super.updateUI(); + if (myDecorator != null && myLogData.getProgress().isRunning()) startLoadingImmediately(); + } + }; myLogData.getProgress().addProgressIndicatorListener(new VcsLogProgress.ProgressListener() { @Override public void progressStarted() { diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripe.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripe.java index 892b01045be3..4df9041f866b 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripe.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripe.java @@ -17,10 +17,11 @@ package com.intellij.vcs.log.ui.frame; import com.intellij.openapi.Disposable; import com.intellij.openapi.ui.LoadingDecorator; -import com.intellij.ui.components.JBLoadingPanel; +import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.NotNullComputable; +import com.intellij.ui.components.JBPanel; import com.intellij.ui.components.panels.NonOpaquePanel; import com.intellij.util.ui.AsyncProcessIcon; -import icons.VcsLogIcons; import org.jetbrains.annotations.NotNull; import javax.swing.*; @@ -28,30 +29,93 @@ import java.awt.*; import java.awt.event.ComponentAdapter; import java.awt.event.ComponentEvent; -public class ProgressStripe extends JBLoadingPanel { - public ProgressStripe(@NotNull JComponent component, @NotNull JComponent toolbar, @NotNull Disposable parent, int startDelayMs) { - super(new BorderLayout(), panel -> new MyLoadingDecorator(component, toolbar, panel, parent, startDelayMs)); - setLoadingText(""); - add(component); +public class ProgressStripe extends JBPanel { + @NotNull + private final JBPanel myPanel; + private final NotNullComputable myCreateLoadingDecorator; + protected MyLoadingDecorator myDecorator; + + public ProgressStripe(@NotNull JComponent targetComponent, @NotNull JComponent toolbar, @NotNull Disposable parent, int startDelayMs) { + super(new BorderLayout()); + myPanel = new JBPanel(new BorderLayout()); + myPanel.setOpaque(false); + myPanel.add(targetComponent); + + myCreateLoadingDecorator = () -> { + Disposable disposable = Disposer.newDisposable(); + Disposer.register(parent, disposable); + return new MyLoadingDecorator(targetComponent, toolbar, myPanel, disposable, startDelayMs); + }; + createLoadingDecorator(); + } + + @Override + public void updateUI() { + super.updateUI(); + if (myCreateLoadingDecorator != null) { + if (myDecorator != null) { + remove(myDecorator.getComponent()); + myDecorator.dispose(); + } + createLoadingDecorator(); + } + } + + private void createLoadingDecorator() { + myDecorator = myCreateLoadingDecorator.compute(); + add(myDecorator.getComponent(), BorderLayout.CENTER); + myDecorator.setLoadingText(""); + } + + public void startLoading() { + myDecorator.startLoading(false); + } + + public void startLoadingImmediately() { + myDecorator.startLoadingImmediately(); + } + + public void stopLoading() { + myDecorator.stopLoading(); } private static class MyLoadingDecorator extends LoadingDecorator { + @NotNull + private final Disposable myDisposable; + @NotNull + private final JComponent myToolbar; + @NotNull + private final ComponentAdapter myListener; private Box.Filler myFiller; public MyLoadingDecorator(@NotNull JComponent component, @NotNull JComponent toolbar, @NotNull JPanel contentPanel, - @NotNull Disposable parent, + @NotNull Disposable disposable, int startDelayMs) { - super(contentPanel, parent, startDelayMs, false, StripesAnimatedIcon.generateIcon(component)); - toolbar.addComponentListener(new ComponentAdapter() { + super(contentPanel, disposable, startDelayMs, false, ProgressStripeIcon.generateIcon(component)); + myDisposable = disposable; + myToolbar = toolbar; + myListener = new ComponentAdapter() { @Override public void componentResized(ComponentEvent e) { super.componentResized(e); - Dimension dimension = new Dimension(0, toolbar.getHeight() - VcsLogIcons.Stripes.getIconHeight() / 2); - myFiller.changeShape(dimension, dimension, dimension); + adjustFiller(); } - }); + }; + myToolbar.addComponentListener(myListener); + adjustFiller(); + } + + private void adjustFiller() { + if (myFiller != null && myToolbar.getHeight() != 0) { + Dimension dimension = new Dimension(0, myToolbar.getHeight() - ProgressStripeIcon.getHeight() / 2); + myFiller.changeShape(dimension, dimension, dimension); + } + } + + public void startLoadingImmediately() { + _startLoading(false); } @Override @@ -68,5 +132,10 @@ public class ProgressStripe extends JBLoadingPanel { return result; } + + public void dispose() { + myToolbar.removeComponentListener(myListener); + Disposer.dispose(myDisposable); + } } } diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripeIcon.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripeIcon.java new file mode 100644 index 000000000000..47920152fcbc --- /dev/null +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/ProgressStripeIcon.java @@ -0,0 +1,150 @@ +/* + * Copyright 2000-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.vcs.log.ui.frame; + +import com.intellij.ui.JBColor; +import com.intellij.util.IconUtil; +import com.intellij.util.containers.ContainerUtil; +import com.intellij.util.ui.AsyncProcessIcon; +import com.intellij.util.ui.JBUI; +import com.intellij.util.ui.UIUtil; +import icons.VcsLogIcons; +import org.jetbrains.annotations.NotNull; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.ComponentAdapter; +import java.awt.event.ComponentEvent; +import java.util.List; + +public class ProgressStripeIcon { + private static final int TRANSLATE = 1; + private static final Icon STRIPES = VcsLogIcons.Stripes; + + private static class StripesIcon implements Icon { + @NotNull + private final JComponent myReferenceComponent; + private final int myShift; + @NotNull + private final Icon myCropIcon; + private final Icon myIcon; + + public StripesIcon(@NotNull JComponent component, int shift, @NotNull Icon icon) { + myReferenceComponent = component; + myShift = shift; + + myIcon = icon; + myCropIcon = IconUtil.cropIcon(icon, new Rectangle(myIcon.getIconWidth() - myShift, 0, myShift, icon.getIconHeight())); + } + + @Override + public void paintIcon(Component c, Graphics g, int x, int y) { + myCropIcon.paintIcon(c, g, x, y); + int shift = myShift; + while (shift < getIconWidth()) { + myIcon.paintIcon(c, g, x + shift, y); + shift += myIcon.getIconWidth(); + } + } + + @Override + public int getIconWidth() { + return myReferenceComponent.getWidth(); + } + + @Override + public int getIconHeight() { + return myIcon.getIconHeight(); + } + } + + private static class GradientIcon implements Icon { + private static final JBColor DARK_BLUE = new JBColor(0x4d9ff8, 0x525659); + private static final JBColor LIGHT_BLUE = new JBColor(0x90c2f8, 0x5e6266); + static final int GRADIENT_WIDTH = JBUI.scale(128); + @NotNull + private final JComponent myReferenceComponent; + private final int myShift; + + private GradientIcon(@NotNull JComponent component, int shift) { + myReferenceComponent = component; + myShift = shift; + } + + @Override + public void paintIcon(Component c, Graphics g, int x, int y) { + Graphics2D g2 = (Graphics2D)g; + int shift = myShift - 2 * GRADIENT_WIDTH; + while (shift < getIconWidth()) { + paint(g2, x, y, shift); + shift += 2 * GRADIENT_WIDTH; + } + } + + public void paint(Graphics2D g2, int x, int y, int shift) { + g2.setPaint(new GradientPaint(x + shift, y, DARK_BLUE, x + shift + GRADIENT_WIDTH, y, LIGHT_BLUE)); + g2.fill(new Rectangle(x + shift, y, GRADIENT_WIDTH, getIconHeight())); + g2.setPaint(new GradientPaint(x + shift + GRADIENT_WIDTH, y, LIGHT_BLUE, x + shift + 2 * GRADIENT_WIDTH, y, DARK_BLUE)); + g2.fill(new Rectangle(x + shift + GRADIENT_WIDTH, y, GRADIENT_WIDTH, getIconHeight())); + } + + @Override + public int getIconWidth() { + return myReferenceComponent.getWidth(); + } + + @Override + public int getIconHeight() { + return STRIPES.getIconHeight(); + } + } + + @NotNull + public static AsyncProcessIcon generateIcon(@NotNull JComponent component) { + List result = ContainerUtil.newArrayList(); + if (UIUtil.isUnderAquaBasedLookAndFeel() && !UIUtil.isUnderDarcula()) { + for (int i = 0; i < 2 * GradientIcon.GRADIENT_WIDTH; i += JBUI.scale(TRANSLATE)) { + result.add(new GradientIcon(component, i)); + } + } + else { + for (int i = 0; i < STRIPES.getIconWidth(); i += JBUI.scale(TRANSLATE)) { + result.add(new StripesIcon(component, i, STRIPES)); + } + result = ContainerUtil.reverse(result); + } + + Icon passive = result.get(0); + AsyncProcessIcon icon = new AsyncProcessIcon("ProgressWithStripes", result.toArray(new Icon[result.size()]), passive) { + @Override + public Dimension getPreferredSize() { + return new Dimension(component.getWidth(), passive.getIconHeight()); + } + }; + component.addComponentListener(new ComponentAdapter() { + @Override + public void componentResized(ComponentEvent e) { + super.componentResized(e); + icon.revalidate(); + } + }); + return icon; + } + + public static int getHeight() { + return STRIPES.getIconHeight(); + } +} diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/StripesAnimatedIcon.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/StripesAnimatedIcon.java deleted file mode 100644 index dac48722e849..000000000000 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/frame/StripesAnimatedIcon.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright 2000-2016 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.intellij.vcs.log.ui.frame; - -import com.intellij.util.IconUtil; -import com.intellij.util.containers.ContainerUtil; -import com.intellij.util.ui.AsyncProcessIcon; -import com.intellij.util.ui.JBUI; -import icons.VcsLogIcons; -import org.jetbrains.annotations.NotNull; - -import javax.swing.*; -import java.awt.*; -import java.awt.event.ComponentAdapter; -import java.awt.event.ComponentEvent; -import java.util.List; - -public class StripesAnimatedIcon implements Icon { - private static final Icon STRIPES = VcsLogIcons.Stripes; - private static final int TRANSLATE = 1; - - @NotNull - private final JComponent myReferenceComponent; - private final int myShift; - @NotNull - private final Icon myCropIcon; - - public StripesAnimatedIcon(@NotNull JComponent component, int shift) { - myReferenceComponent = component; - myShift = shift; - - myCropIcon = IconUtil.cropIcon(STRIPES, new Rectangle(STRIPES.getIconWidth() - myShift, 0, myShift, STRIPES.getIconHeight())); - } - - @Override - public void paintIcon(Component c, Graphics g, int x, int y) { - myCropIcon.paintIcon(c, g, x, y); - int shift = myShift; - while (shift < getIconWidth()) { - STRIPES.paintIcon(c, g, x + shift, y); - shift += STRIPES.getIconWidth(); - } - } - - @Override - public int getIconWidth() { - return myReferenceComponent.getWidth(); - } - - @Override - public int getIconHeight() { - return STRIPES.getIconHeight(); - } - - @NotNull - public static AsyncProcessIcon generateIcon(@NotNull JComponent component) { - List result = ContainerUtil.newArrayList(); - for (int i = 0; i < STRIPES.getIconWidth(); i += JBUI.scale(TRANSLATE)) { - result.add(new StripesAnimatedIcon(component, i)); - } - AsyncProcessIcon icon = new AsyncProcessIcon("ProgressWithStripes", result.toArray(new Icon[result.size()]), result.get(0)) { - @Override - public Dimension getPreferredSize() { - return new Dimension(component.getWidth(), STRIPES.getIconHeight()); - } - }; - component.addComponentListener(new ComponentAdapter() { - @Override - public void componentResized(ComponentEvent e) { - super.componentResized(e); - icon.revalidate(); - } - }); - return icon; - } -} diff --git a/platform/xdebugger-api/src/com/intellij/xdebugger/XDebugProcess.java b/platform/xdebugger-api/src/com/intellij/xdebugger/XDebugProcess.java index 87844d448f8d..b90e72c29174 100644 --- a/platform/xdebugger-api/src/com/intellij/xdebugger/XDebugProcess.java +++ b/platform/xdebugger-api/src/com/intellij/xdebugger/XDebugProcess.java @@ -109,6 +109,7 @@ public abstract class XDebugProcess { /** * @deprecated Use {@link #startForceStepInto(XSuspendContext)} instead */ + @SuppressWarnings("unused") @Deprecated public void startForceStepInto(){ //noinspection deprecation @@ -123,8 +124,7 @@ public abstract class XDebugProcess { * Do not call this method directly. Use {@link XDebugSession#forceStepInto} instead */ public void startForceStepInto(@Nullable XSuspendContext context) { - //noinspection deprecation - startForceStepInto(); + startStepInto(context); } /** diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/ConvertOctalLiteralToDecimalFix.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/ConvertOctalLiteralToDecimalFix.java index c4545e760c6d..ed3bb690a7ff 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/ConvertOctalLiteralToDecimalFix.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/ConvertOctalLiteralToDecimalFix.java @@ -1,5 +1,5 @@ /* - * Copyright 2010 Bas Leijdekkers + * Copyright 2010-2016 Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,14 +17,16 @@ package com.siyeh.ig.numeric; import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.openapi.project.Project; -import com.intellij.psi.*; -import com.intellij.util.IncorrectOperationException; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiLiteralExpression; +import com.intellij.psi.PsiType; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.InspectionGadgetsFix; +import com.siyeh.ig.PsiReplacementUtil; import org.jetbrains.annotations.NotNull; -class ConvertOctalLiteralToDecimalFix - extends InspectionGadgetsFix { +class ConvertOctalLiteralToDecimalFix extends InspectionGadgetsFix { + @Override @NotNull public String getFamilyName() { @@ -34,24 +36,21 @@ class ConvertOctalLiteralToDecimalFix @Override @NotNull public String getName() { - return InspectionGadgetsBundle.message( - "convert.octal.literal.to.decimal.literal.quickfix"); + return InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix"); } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { + protected void doFix(Project project, ProblemDescriptor descriptor) { final PsiElement element = descriptor.getPsiElement(); - if (!(element instanceof PsiLiteralExpression)) return; - - final Object value = ((PsiLiteralExpression)element).getValue(); - if (value == null) return; - - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); - final PsiExpression decimalNumber = - factory.createExpressionFromText(value.toString(), - element); - element.replace(decimalNumber); + if (!(element instanceof PsiLiteralExpression)) { + return; + } + final PsiLiteralExpression literalExpression = (PsiLiteralExpression)element; + final Object value = literalExpression.getValue(); + if (value == null) { + return; + } + final String decimalText = value + (PsiType.LONG.equals(literalExpression.getType()) ? "L" : ""); + PsiReplacementUtil.replaceExpression(literalExpression, decimalText); } } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/RemoveLeadingZeroFix.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/RemoveLeadingZeroFix.java index 9ddd84a1b54e..91d78fb2559e 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/RemoveLeadingZeroFix.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/numeric/RemoveLeadingZeroFix.java @@ -1,5 +1,5 @@ /* - * Copyright 2010 Bas Leijdekkers + * Copyright 2010-2016 Bas Leijdekkers * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,13 +17,11 @@ package com.siyeh.ig.numeric; import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.openapi.project.Project; -import com.intellij.psi.JavaPsiFacade; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiElementFactory; -import com.intellij.psi.PsiExpression; -import com.intellij.util.IncorrectOperationException; +import com.intellij.psi.PsiLiteralExpression; +import com.intellij.psi.PsiType; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.InspectionGadgetsFix; +import com.siyeh.ig.PsiReplacementUtil; import org.jetbrains.annotations.NotNull; class RemoveLeadingZeroFix extends InspectionGadgetsFix { @@ -31,8 +29,7 @@ class RemoveLeadingZeroFix extends InspectionGadgetsFix { @Override @NotNull public String getName() { - return InspectionGadgetsBundle.message( - "remove.leading.zero.to.make.decimal.quickfix"); + return InspectionGadgetsBundle.message("remove.leading.zero.to.make.decimal.quickfix"); } @NotNull @@ -42,11 +39,10 @@ class RemoveLeadingZeroFix extends InspectionGadgetsFix { } @Override - protected void doFix(Project project, ProblemDescriptor descriptor) - throws IncorrectOperationException { - final PsiElement element = descriptor.getPsiElement(); - final String text = element.getText(); - final int max = text.length() - 1; + protected void doFix(Project project, ProblemDescriptor descriptor) { + final PsiLiteralExpression literal = (PsiLiteralExpression)descriptor.getPsiElement(); + final String text = literal.getText(); + final int max = text.length() - (PsiType.LONG.equals(literal.getType()) ? 2 : 1); if (max < 1) { return; } @@ -54,12 +50,7 @@ class RemoveLeadingZeroFix extends InspectionGadgetsFix { while (index < max && (text.charAt(index) == '0' || text.charAt(index) == '_')) { index++; } - final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project); - final PsiElementFactory factory = psiFacade.getElementFactory(); final String textWithoutLeadingZeros = text.substring(index); - final PsiExpression decimalNumber = - factory.createExpressionFromText(textWithoutLeadingZeros, - element); - element.replace(decimalNumber); + PsiReplacementUtil.replaceExpression(literal, textWithoutLeadingZeros); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.after.java new file mode 100644 index 000000000000..cce878329cfb --- /dev/null +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.after.java @@ -0,0 +1,3 @@ +class C {{ + long l = 0L; +}} \ No newline at end of file diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.java new file mode 100644 index 000000000000..bf16602fe852 --- /dev/null +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/ConvertOctalToDecimalLong.java @@ -0,0 +1,3 @@ +class C {{ + long l = 00L; +}} \ No newline at end of file diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.after.java new file mode 100644 index 000000000000..82bb684f1bca --- /dev/null +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.after.java @@ -0,0 +1,3 @@ +class C { + long l = 0L; +} \ No newline at end of file diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.java new file mode 100644 index 000000000000..c76f55bffad1 --- /dev/null +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/numeric/octal/RemoveLeadingZeroLong.java @@ -0,0 +1,3 @@ +class C { + long l = 00L; +} \ No newline at end of file diff --git a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/numeric/OctalLiteralFixesTest.java b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/numeric/OctalLiteralFixesTest.java index cfdd64db2eb6..558658ee118c 100644 --- a/plugins/InspectionGadgets/testsrc/com/siyeh/ig/numeric/OctalLiteralFixesTest.java +++ b/plugins/InspectionGadgets/testsrc/com/siyeh/ig/numeric/OctalLiteralFixesTest.java @@ -25,16 +25,24 @@ public class OctalLiteralFixesTest extends IGQuickFixesTestCase { myFixture.enableInspections(new OctalLiteralInspection()); } - public void testConvertOctalToDecimal1() { - doTest("ConvertToDecimal1", InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix")); + public void testConvertToDecimal1() { + doTest(InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix")); } - public void testConvertOctalToDecimal2() { - doTest("ConvertToDecimal2", InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix")); + public void testConvertToDecimal2() { + doTest(InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix")); + } + + public void testConvertOctalToDecimalLong() { + doTest(InspectionGadgetsBundle.message("convert.octal.literal.to.decimal.literal.quickfix")); } public void testRemoveLeadingZero() { - doTest("RemoveLeadingZero", InspectionGadgetsBundle.message("remove.leading.zero.to.make.decimal.quickfix")); + doTest(InspectionGadgetsBundle.message("remove.leading.zero.to.make.decimal.quickfix")); + } + + public void testRemoveLeadingZeroLong() { + doTest(InspectionGadgetsBundle.message("remove.leading.zero.to.make.decimal.quickfix")); } @Override diff --git a/plugins/git4idea/src/git4idea/GitVcs.java b/plugins/git4idea/src/git4idea/GitVcs.java index 5de354f4d328..eed4c7bb4549 100644 --- a/plugins/git4idea/src/git4idea/GitVcs.java +++ b/plugins/git4idea/src/git4idea/GitVcs.java @@ -168,7 +168,7 @@ public class GitVcs extends AbstractVcs { * @param task the task to run */ public static void runInBackground(Task.Backgroundable task) { - task.queue(); + UIUtil.invokeLaterIfNeeded(() -> task.queue()); } @Override diff --git a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleDependenciesImportingTest.java b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleDependenciesImportingTest.java index 425cf98da138..53e81ba7b98a 100644 --- a/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleDependenciesImportingTest.java +++ b/plugins/gradle/testSources/org/jetbrains/plugins/gradle/importing/GradleDependenciesImportingTest.java @@ -540,7 +540,7 @@ public class GradleDependenciesImportingTest extends GradleImportingTestCase { } @Test - @TargetVersions("2.5+") + @TargetVersions("2.6+") public void testProjectSubstitutions() throws Exception { createSettingsFile("include 'core'\n" + "include 'service'\n" + @@ -644,4 +644,41 @@ public class GradleDependenciesImportingTest extends GradleImportingTestCase { assertModuleLibDepScope("project", "Gradle: junit:junit:4.11", DependencyScope.COMPILE); assertModuleLibDepScope("project", "Gradle: org.hamcrest:hamcrest-core:1.3", DependencyScope.PROVIDED, DependencyScope.RUNTIME); } + + @Test + @TargetVersions("2.0+") + public void testProvidedTransitiveDependencies() throws Exception { + createSettingsFile("include 'projectA', 'projectB', 'projectC' "); + importProject( + "project(':projectA') {\n" + + " apply plugin: 'java'\n" + + "}\n" + + "project(':projectB') {\n" + + " apply plugin: 'java'\n" + + " dependencies {\n" + + " compile project(':projectA')\n" + + " }\n" + + "}\n" + + "project(':projectC') {\n" + + " apply plugin: 'war'\n" + + " dependencies {\n" + + " providedCompile project(':projectB')\n" + + " }\n" + + "}" + ); + + assertModules("project", "projectA", "projectA_main", "projectA_test", "projectB", "projectB_main", "projectB_test", "projectC", "projectC_main", "projectC_test"); + + assertModuleModuleDepScope("projectB_main", "projectA_main", DependencyScope.COMPILE); + assertModuleModuleDepScope("projectC_main", "projectA_main", DependencyScope.PROVIDED); + assertModuleModuleDepScope("projectC_main", "projectB_main", DependencyScope.PROVIDED); + + importProjectUsingSingeModulePerGradleProject(); + assertModules("project", "projectA", "projectB", "projectC"); + assertModuleModuleDepScope("projectB", "projectA", DependencyScope.COMPILE); + if(GradleVersion.version(gradleVersion).compareTo(GradleVersion.version("2.5")) >= 0) { + assertModuleModuleDepScope("projectC", "projectA", DependencyScope.PROVIDED); + } + assertModuleModuleDepScope("projectC", "projectB", DependencyScope.PROVIDED); + } } diff --git a/plugins/gradle/tooling-extension-impl/src/org/jetbrains/plugins/gradle/tooling/util/DependencyResolverImpl.groovy b/plugins/gradle/tooling-extension-impl/src/org/jetbrains/plugins/gradle/tooling/util/DependencyResolverImpl.groovy index 69472611725d..1c720729cf3b 100644 --- a/plugins/gradle/tooling-extension-impl/src/org/jetbrains/plugins/gradle/tooling/util/DependencyResolverImpl.groovy +++ b/plugins/gradle/tooling-extension-impl/src/org/jetbrains/plugins/gradle/tooling/util/DependencyResolverImpl.groovy @@ -58,7 +58,7 @@ import java.util.regex.Pattern class DependencyResolverImpl implements DependencyResolver { private static isArtifactResolutionQuerySupported = GradleVersion.current() >= GradleVersion.version("2.0") - private static isDependencySubstitutionsSupported = GradleVersion.current() >= GradleVersion.version("2.5") + private static isDependencySubstitutionsSupported = GradleVersion.current() > GradleVersion.version("2.5") @NotNull private final Project myProject @@ -143,10 +143,15 @@ class DependencyResolverImpl implements DependencyResolver { Map componentResultsMap = [:]; componentResults.each { componentResultsMap.put(it.id, it) } - Multimap configurationProjectDependencies = ArrayListMultimap.create() - configuration.incoming.dependencies.findAll { it instanceof ProjectDependency }.each { - configurationProjectDependencies.put(toComponentIdentifier(it.group, it.name, it.version), it as ProjectDependency) + def projectDeps + projectDeps = { Configuration conf, map = ArrayListMultimap.create() -> + conf.incoming.dependencies.findAll { it instanceof ProjectDependency }.each { it -> + map.put(toComponentIdentifier(it.group, it.name, it.version), it as ProjectDependency) + projectDeps((it as ProjectDependency).projectConfiguration, map) + } + map } + Multimap configurationProjectDependencies = projectDeps(configuration) ResolutionResult resolutionResult = configuration.incoming.resolutionResult if(!configuration.resolvedConfiguration.hasError()) { diff --git a/plugins/gradle/tooling-extension-impl/testSources/org/jetbrains/plugins/gradle/tooling/builder/AbstractModelBuilderTest.java b/plugins/gradle/tooling-extension-impl/testSources/org/jetbrains/plugins/gradle/tooling/builder/AbstractModelBuilderTest.java index 051b498a3429..a96fa48f15af 100644 --- a/plugins/gradle/tooling-extension-impl/testSources/org/jetbrains/plugins/gradle/tooling/builder/AbstractModelBuilderTest.java +++ b/plugins/gradle/tooling-extension-impl/testSources/org/jetbrains/plugins/gradle/tooling/builder/AbstractModelBuilderTest.java @@ -69,7 +69,7 @@ public abstract class AbstractModelBuilderTest { public static final Object[][] SUPPORTED_GRADLE_VERSIONS = { {"1.9"}, /*{"1.10"}, {"1.11"},*/ {"1.12"}, - {"2.0"}, /*{"2.1"}, {"2.2"} , {"2.3"}, {"2.4"}, {"2.5"}, {"2.6"}, {"2.7"}, {"2.8"},*/ {"2.9"}, /*{"2.10"}, {"2.11"}, {"2.12"},*/ {"2.13"} + {"2.0"}, /*{"2.1"}, {"2.2"} , {"2.3"}, {"2.4"}, */{"2.5"}, /*{"2.6"}, {"2.7"}, {"2.8"},*/ {"2.9"}, /*{"2.10"}, {"2.11"}, {"2.12"},*/ {"2.13"} }; public static final String BASE_GRADLE_VERSION = String.valueOf(SUPPORTED_GRADLE_VERSIONS[SUPPORTED_GRADLE_VERSIONS.length - 1][0]); diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/local/GroovyPostHighlightingPass.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/local/GroovyPostHighlightingPass.java index b0f3b32c8699..d132d6216476 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/local/GroovyPostHighlightingPass.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/codeInspection/local/GroovyPostHighlightingPass.java @@ -54,6 +54,7 @@ import org.jetbrains.plugins.groovy.lang.psi.GroovyFile; import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult; import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrField; import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock; +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression; import org.jetbrains.plugins.groovy.lang.psi.api.statements.params.GrParameter; import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.GrTypeDefinition; import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrAccessorMethod; @@ -115,8 +116,12 @@ public class GroovyPostHighlightingPass extends TextEditorHighlightingPass { myFile.accept(new PsiRecursiveElementWalkingVisitor() { @Override public void visitElement(PsiElement element) { - if (element instanceof GrReferenceElement) { - for (GroovyResolveResult result : ((GrReferenceElement)element).multiResolve(true)) { + if (element instanceof GrReferenceExpression && !((GrReferenceElement)element).isQualified()) { + GroovyResolveResult[] results = ((GrReferenceExpression)element).multiResolve(false); + if (results.length == 0) { + results = ((GrReferenceExpression)element).multiResolve(true); + } + for (GroovyResolveResult result : results) { PsiElement resolved = result.getElement(); if (resolved instanceof GrParameter && resolved.getContainingFile() == myFile) { usedParams.put((GrParameter)resolved, Boolean.TRUE); diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/DslPointcut.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/DslPointcut.java index ce33b6e9ca4e..7c76247bf9da 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/DslPointcut.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/DslPointcut.java @@ -118,9 +118,9 @@ public abstract class DslPointcut { @Override List matches(GdslType src, ProcessingContext context) { - final PsiFile placeFile = context.get(GdslUtil.INITIAL_CONTEXT).getPlaceFile(); + final PsiFile placeFile = context.get(GdslUtil.INITIAL_CONTEXT).justGetPlaceFile(); if (ClassContextFilter.isSubtype(src.psiType, placeFile, (String)arg)) { - return Arrays.asList(src); + return Collections.singletonList(src); } return null; } diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/toplevel/ClassContextFilter.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/toplevel/ClassContextFilter.java index 4c543b9e065e..59e5aba7570d 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/toplevel/ClassContextFilter.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/dsl/toplevel/ClassContextFilter.java @@ -15,14 +15,10 @@ */ package org.jetbrains.plugins.groovy.dsl.toplevel; -import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Key; -import com.intellij.openapi.util.Pair; import com.intellij.patterns.ElementPattern; import com.intellij.psi.*; -import com.intellij.util.ProcessingContext; import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.plugins.groovy.dsl.GroovyClassDescriptor; import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.ClassUtil; import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil; @@ -31,27 +27,17 @@ import java.util.Map; /** * @author peter */ -public class ClassContextFilter implements ContextFilter { - private final Condition> myPattern; +public class ClassContextFilter { - public ClassContextFilter(Condition> pattern) { - myPattern = pattern; - } - - @Override - public boolean isApplicable(GroovyClassDescriptor descriptor, ProcessingContext ctx) { - return myPattern.value(Pair.create(descriptor.getPsiType(), descriptor.getPlaceFile())); - } - - public static ClassContextFilter fromClassPattern(final ElementPattern pattern) { - return new ClassContextFilter(pair -> { - final PsiType type = pair.first; + public static ContextFilter fromClassPattern(ElementPattern pattern) { + return (descriptor, ctx) -> { + PsiType type = descriptor.getPsiType(); return type instanceof PsiClassType && pattern.accepts(((PsiClassType)type).resolve()); - }); + }; } - public static ClassContextFilter subtypeOf(final String typeText) { - return new ClassContextFilter(p -> isSubtype(p.first, p.second, typeText)); + public static ContextFilter subtypeOf(String typeText) { + return (descriptor, ctx) -> isSubtype(descriptor.getPsiType(), descriptor.justGetPlaceFile(), typeText); } public static boolean isSubtype(PsiType checked, PsiFile placeFile, String typeText) { diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceExpressionImpl.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceExpressionImpl.java index 479ad9c0342b..a60a573f5118 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceExpressionImpl.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceExpressionImpl.java @@ -459,7 +459,7 @@ public class GrReferenceExpressionImpl extends GrReferenceElementImpl= 0; i--) { - if (!processQualifierType(conjuncts[i], state)) return false; - } - return true; - } -} diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceResolveRunner.kt b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceResolveRunner.kt new file mode 100644 index 000000000000..2ea4489e9094 --- /dev/null +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/GrReferenceResolveRunner.kt @@ -0,0 +1,137 @@ +/* + * Copyright 2000-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions + +import com.intellij.psi.* +import com.intellij.psi.scope.PsiScopeProcessor +import com.intellij.psi.util.InheritanceUtil +import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes +import org.jetbrains.plugins.groovy.lang.psi.api.SpreadState +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall +import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression +import org.jetbrains.plugins.groovy.lang.psi.impl.GrTraitType +import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager +import org.jetbrains.plugins.groovy.lang.psi.typeEnhancers.ClosureParameterEnhancer +import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil +import org.jetbrains.plugins.groovy.lang.resolve.ClosureMissingMethodContributor +import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil +import org.jetbrains.plugins.groovy.lang.resolve.processors.ClassHint + +fun resolveReferenceExpression(place: GrReferenceExpression, processor: PsiScopeProcessor): Boolean { + val qualifier = place.qualifier + if (qualifier == null) { + if (!ResolveUtil.treeWalkUp(place, processor, true)) return false + return place.context !is GrMethodCall || ClosureMissingMethodContributor.processMethodsFromClosures(place, processor) + } + else { + if (place.dotTokenType === GroovyTokenTypes.mSPREAD_DOT) { + val qType = qualifier.type + val componentType = ClosureParameterEnhancer.findTypeForIteration(qType, place) + if (componentType != null) { + val state = ResolveState.initial().put(ClassHint.RESOLVE_CONTEXT, qualifier).put(SpreadState.SPREAD_STATE, SpreadState.create(qType, null)) + return processQualifierType(place, componentType, processor, state) + } + } + else { + if (ResolveUtil.isClassReference(place)) return false + if (!processJavaLangClass(place, qualifier, processor)) return false + return processQualifier(place, qualifier, processor) + } + } + return true +} + +fun processJavaLangClass(place: PsiElement, qualifier: GrExpression, processor: PsiScopeProcessor): Boolean { + if (qualifier !is GrReferenceExpression) return true + + //optimization: only 'class' or 'this' in static context can be an alias of java.lang.Class + if ("class" != qualifier.referenceName && !PsiUtil.isThisReference(qualifier) && qualifier.resolve() !is PsiClass) return true + + val classType = ResolveUtil.unwrapClassType(qualifier.getType()) + return classType?.let { + val state = ResolveState.initial().put(ClassHint.RESOLVE_CONTEXT, qualifier) + processQualifierType(place, classType, processor, state) + } ?: true +} + +fun processQualifier(place: PsiElement, qualifier: GrExpression, processor: PsiScopeProcessor): Boolean { + val qualifierType = qualifier.type + val state = ResolveState.initial().put(ClassHint.RESOLVE_CONTEXT, qualifier) + if (qualifierType == null || PsiType.VOID == qualifierType) { + if (qualifier is GrReferenceExpression) { + val resolved = qualifier.resolve() + if (resolved is PsiClass) { + if (!ResolveUtil.processClassDeclarations((resolved as PsiClass?)!!, processor, state, null, place)) return false + } + else if (resolved != null && !resolved.processDeclarations(processor, state, null, place)) return false + if (resolved !is PsiPackage) { + val objectQualifier = TypesUtil.getJavaLangObject(place) + if (!processQualifierType(place, objectQualifier, processor, state)) return false + } + } + } + else { + if (!processQualifierType(place, qualifierType, processor, state)) return false + } + return true +} + +fun processQualifierType(place: PsiElement, qualifierType: PsiType, processor: PsiScopeProcessor, state: ResolveState): Boolean { + val type = if (qualifierType is PsiDisjunctionType) qualifierType.leastUpperBound else qualifierType + return doProcessQualifierType(place, type, processor, state) +} + +fun doProcessQualifierType(place: PsiElement, qualifierType: PsiType, processor: PsiScopeProcessor, state: ResolveState): Boolean { + if (qualifierType is PsiIntersectionType) { + return qualifierType.conjuncts.find { !processQualifierType(place, it, processor, state) } == null + } + + if (qualifierType is PsiCapturedWildcardType) { + val wildcard = qualifierType.wildcard + if (wildcard.isExtends) { + return processQualifierType(place, wildcard.extendsBound, processor, state) + } + } + + // Process trait type conjuncts in reversed order because last applied trait matters. + if (qualifierType is GrTraitType) return qualifierType.conjuncts.findLast { !processQualifierType(place, it, processor, state) } == null + + if (qualifierType is PsiClassType) { + val qualifierResult = qualifierType.resolveGenerics() + qualifierResult.element?.let { + val resolveState = state.put(PsiSubstitutor.KEY, qualifierResult.substitutor) + if (!ResolveUtil.processClassDeclarations(it, processor, resolveState, null, place)) return false + } + } + else if (qualifierType is PsiArrayType) { + GroovyPsiManager.getInstance(place.project).getArrayClass(qualifierType.componentType)?.let { + if (!ResolveUtil.processClassDeclarations(it, processor, state, null, place)) return false + } + } + + if (place.parent !is GrMethodCall && InheritanceUtil.isInheritor(qualifierType, CommonClassNames.JAVA_UTIL_COLLECTION)) { + ClosureParameterEnhancer.findTypeForIteration(qualifierType, place)?.let { + val spreadState = state.get(SpreadState.SPREAD_STATE) + val resolveState = state.put(SpreadState.SPREAD_STATE, SpreadState.create(qualifierType, spreadState)) + if (!processQualifierType(place, it, processor, resolveState)) return false + } + } + + if (!ResolveUtil.processCategoryMembers(place, processor, state)) return false + if (!ResolveUtil.processNonCodeMembers(qualifierType, processor, place, state)) return false + return true +} \ No newline at end of file diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/TypesUtil.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/TypesUtil.java index 0ea7f132ff3e..3b6fadf3a8d2 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/TypesUtil.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/expressions/TypesUtil.java @@ -32,6 +32,7 @@ import com.intellij.util.containers.HashMap; import gnu.trove.THashMap; import gnu.trove.TIntObjectHashMap; import gnu.trove.TObjectIntHashMap; +import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -634,6 +635,7 @@ public class TypesUtil { return type; } + @Contract("null, _ -> false") public static boolean isClassType(@Nullable PsiType type, @NotNull String qName) { return qName.equals(getQualifiedName(type)); } diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/typeEnhancers/ClosureParameterEnhancer.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/typeEnhancers/ClosureParameterEnhancer.java index b48fabeb69d8..85c1e11a1890 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/typeEnhancers/ClosureParameterEnhancer.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/typeEnhancers/ClosureParameterEnhancer.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,6 +22,7 @@ import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.util.containers.hash.HashMap; import com.intellij.util.containers.hash.HashSet; +import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult; @@ -286,6 +287,8 @@ public class ClosureParameterEnhancer extends AbstractClosureParameterEnhancer { return PsiImplUtil.normalizeWildcardTypeByPosition(type, qualifier); } + @Contract("null,_ -> null") + @Nullable public static PsiType findTypeForIteration(@Nullable PsiType type, @NotNull PsiElement context) { final PsiManager manager = context.getManager(); final GlobalSearchScope resolveScope = context.getResolveScope(); diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java index b712f72ec722..e3abb152be94 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/indices/MavenIndex.java @@ -394,7 +394,9 @@ public class MavenIndex { myUpdateTimestamp = System.currentTimeMillis(); } - oldData.close(true); + if(oldData != null) { + oldData.close(true); + } for (File each : FileUtil.notNullize(myDir.listFiles())) { if (each.getName().startsWith(DATA_DIR_PREFIX) && !each.getName().equals(myDataDirName)) { diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.form b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.form index 3313086040c7..e744ab1440f4 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.form +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.form @@ -71,7 +71,7 @@ - + @@ -82,7 +82,7 @@ - + @@ -117,21 +117,13 @@ - + - - - - - - - - - + @@ -161,6 +153,25 @@ + + + + + + + + + + + + + + + + + + + diff --git a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.java b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.java index 12a6e4862db4..1d55cb065347 100644 --- a/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.java +++ b/plugins/maven/src/main/java/org/jetbrains/idea/maven/utils/library/propertiesEditor/RepositoryLibraryPropertiesEditor.java @@ -74,6 +74,7 @@ public class RepositoryLibraryPropertiesEditor { this.model = model; this.project = project == null ? ProjectManager.getInstance().getDefaultProject() : project; repositoryLibraryDescription = description; + mavenCoordinates.setCopyable(true); myReloadButton.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { @@ -84,7 +85,7 @@ public class RepositoryLibraryPropertiesEditor { @Override public void onChange(RepositoryLibraryPropertiesEditor editor) { onChangeListener.onChange(editor); - mavenCoordinates.setText("Maven: " + repositoryLibraryDescription.getMavenCoordinates(model.getVersion())); + mavenCoordinates.setText(repositoryLibraryDescription.getMavenCoordinates(model.getVersion())); } }; reloadVersionsAsync(); @@ -253,7 +254,7 @@ public class RepositoryLibraryPropertiesEditor { return; } - ApplicationManager.getApplication().invokeLater(() -> initVersionsPanel(), ModalityState.any()); + ApplicationManager.getApplication().invokeLater(this::initVersionsPanel, ModalityState.any()); } private void versionsFailedToLoad() { diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython.c b/python/helpers/pydev/_pydevd_bundle/pydevd_cython.c index af3ef1a972cd..736b3db593b6 100644 --- a/python/helpers/pydev/_pydevd_bundle/pydevd_cython.c +++ b/python/helpers/pydev/_pydevd_bundle/pydevd_cython.c @@ -483,7 +483,7 @@ struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo { }; -/* "_pydevd_bundle/pydevd_cython.pyx":934 +/* "_pydevd_bundle/pydevd_cython.pyx":935 * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * cdef class ThreadTracer: # <<<<<<<<<<<<<< @@ -8180,7 +8180,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * frame.f_back.f_locals[RETURN_VALUES_PREFIX + name] = arg # <<<<<<<<<<<<<< * if main_debugger.remove_return_values_flag: - * # show return values was turned off, we should remove them from locals dict + * # Showing return values was turned off, we should remove them from locals dict. */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 471; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); @@ -8227,8 +8227,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * frame.f_back.f_locals[RETURN_VALUES_PREFIX + name] = arg * if main_debugger.remove_return_values_flag: # <<<<<<<<<<<<<< - * # show return values was turned off, we should remove them from locals dict - * for var_name in dict_keys(frame.f_locals): + * # Showing return values was turned off, we should remove them from locals dict. + * # The values can be in the current frame or in the back one */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); @@ -8236,16 +8236,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__pyx_t_5) { - /* "_pydevd_bundle/pydevd_cython.pyx":474 - * if main_debugger.remove_return_values_flag: - * # show return values was turned off, we should remove them from locals dict + /* "_pydevd_bundle/pydevd_cython.pyx":475 + * # Showing return values was turned off, we should remove them from locals dict. + * # The values can be in the current frame or in the back one * for var_name in dict_keys(frame.f_locals): # <<<<<<<<<<<<<< * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_locals, var_name) */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_keys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_keys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { @@ -8258,17 +8258,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } } if (!__pyx_t_10) { - __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_9); } else { - __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL; __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_11, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_11, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } @@ -8277,9 +8277,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __pyx_t_4 = __pyx_t_9; __Pyx_INCREF(__pyx_t_4); __pyx_t_12 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_12 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_12 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_9); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; for (;;) { @@ -8287,17 +8287,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_9 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); #endif } else { if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_9); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} #else - __pyx_t_9 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); #endif } @@ -8307,7 +8307,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } break; } @@ -8316,16 +8316,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_XDECREF_SET(__pyx_v_var_name, __pyx_t_9); __pyx_t_9 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":475 - * # show return values was turned off, we should remove them from locals dict + /* "_pydevd_bundle/pydevd_cython.pyx":476 + * # The values can be in the current frame or in the back one * for var_name in dict_keys(frame.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): # <<<<<<<<<<<<<< * dict_pop(frame.f_locals, var_name) * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): */ - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_var_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_var_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); - __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_RETURN_VALUES_PREFIX); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_RETURN_VALUES_PREFIX); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_11))) { @@ -8338,35 +8338,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } } if (!__pyx_t_10) { - __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_9); } else { - __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_10); __pyx_t_10 = NULL; __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_8); __pyx_t_8 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 475; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (__pyx_t_5) { - /* "_pydevd_bundle/pydevd_cython.pyx":476 + /* "_pydevd_bundle/pydevd_cython.pyx":477 * for var_name in dict_keys(frame.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_locals, var_name) # <<<<<<<<<<<<<< * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * for var_name in dict_keys(frame.f_back.f_locals): */ - __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_pop); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_pop); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = NULL; __pyx_t_15 = 0; @@ -8380,7 +8380,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __pyx_t_15 = 1; } } - __pyx_t_10 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_10 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -8391,14 +8391,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_GIVEREF(__pyx_v_var_name); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_15, __pyx_v_var_name); __pyx_t_14 = 0; - __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":475 - * # show return values was turned off, we should remove them from locals dict + /* "_pydevd_bundle/pydevd_cython.pyx":476 + * # The values can be in the current frame or in the back one * for var_name in dict_keys(frame.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): # <<<<<<<<<<<<<< * dict_pop(frame.f_locals, var_name) @@ -8406,9 +8406,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r */ } - /* "_pydevd_bundle/pydevd_cython.pyx":474 - * if main_debugger.remove_return_values_flag: - * # show return values was turned off, we should remove them from locals dict + /* "_pydevd_bundle/pydevd_cython.pyx":475 + * # Showing return values was turned off, we should remove them from locals dict. + * # The values can be in the current frame or in the back one * for var_name in dict_keys(frame.f_locals): # <<<<<<<<<<<<<< * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_locals, var_name) @@ -8416,41 +8416,41 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":477 + /* "_pydevd_bundle/pydevd_cython.pyx":478 * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_locals, var_name) * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): # <<<<<<<<<<<<<< * for var_name in dict_keys(frame.f_back.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): */ - __pyx_t_6 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_6 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_t_7 = (__pyx_t_6 != 0); if (__pyx_t_7) { } else { __pyx_t_5 = __pyx_t_7; goto __pyx_L24_bool_binop_done; } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = PyObject_HasAttr(__pyx_t_4, __pyx_n_s_f_locals); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_7 = PyObject_HasAttr(__pyx_t_4, __pyx_n_s_f_locals); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_6 = (__pyx_t_7 != 0); __pyx_t_5 = __pyx_t_6; __pyx_L24_bool_binop_done:; if (__pyx_t_5) { - /* "_pydevd_bundle/pydevd_cython.pyx":478 + /* "_pydevd_bundle/pydevd_cython.pyx":479 * dict_pop(frame.f_locals, var_name) * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * for var_name in dict_keys(frame.f_back.f_locals): # <<<<<<<<<<<<<< * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_back.f_locals, var_name) */ - __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_keys); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_keys); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; @@ -8464,17 +8464,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } } if (!__pyx_t_11) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_4); } else { - __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_11); __pyx_t_11 = NULL; __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_10); __pyx_t_10 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } @@ -8483,9 +8483,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __pyx_t_9 = __pyx_t_4; __Pyx_INCREF(__pyx_t_9); __pyx_t_12 = 0; __pyx_t_13 = NULL; } else { - __pyx_t_12 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_12 = -1; __pyx_t_9 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); - __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = Py_TYPE(__pyx_t_9)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { @@ -8493,17 +8493,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r if (likely(PyList_CheckExact(__pyx_t_9))) { if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_9)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PyList_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_9)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_9, __pyx_t_12); __Pyx_INCREF(__pyx_t_4); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} #else - __pyx_t_4 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PySequence_ITEM(__pyx_t_9, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); #endif } @@ -8513,7 +8513,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 478; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } break; } @@ -8522,16 +8522,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_XDECREF_SET(__pyx_v_var_name, __pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":479 + /* "_pydevd_bundle/pydevd_cython.pyx":480 * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * for var_name in dict_keys(frame.f_back.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): # <<<<<<<<<<<<<< * dict_pop(frame.f_back.f_locals, var_name) * main_debugger.remove_return_values_flag = False */ - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_var_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_var_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); - __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_RETURN_VALUES_PREFIX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_RETURN_VALUES_PREFIX); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_14))) { @@ -8544,37 +8544,37 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } } if (!__pyx_t_11) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_4); } else { - __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_11); __pyx_t_11 = NULL; __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_10); __pyx_t_10 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_5) { - /* "_pydevd_bundle/pydevd_cython.pyx":480 + /* "_pydevd_bundle/pydevd_cython.pyx":481 * for var_name in dict_keys(frame.f_back.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_back.f_locals, var_name) # <<<<<<<<<<<<<< * main_debugger.remove_return_values_flag = False * except: */ - __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_pop); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_pop); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); - __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; @@ -8589,7 +8589,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __pyx_t_15 = 1; } } - __pyx_t_11 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_11 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __pyx_t_8 = NULL; @@ -8600,13 +8600,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_GIVEREF(__pyx_v_var_name); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_15, __pyx_v_var_name); __pyx_t_10 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":479 + /* "_pydevd_bundle/pydevd_cython.pyx":480 * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * for var_name in dict_keys(frame.f_back.f_locals): * if var_name.startswith(RETURN_VALUES_PREFIX): # <<<<<<<<<<<<<< @@ -8615,7 +8615,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r */ } - /* "_pydevd_bundle/pydevd_cython.pyx":478 + /* "_pydevd_bundle/pydevd_cython.pyx":479 * dict_pop(frame.f_locals, var_name) * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * for var_name in dict_keys(frame.f_back.f_locals): # <<<<<<<<<<<<<< @@ -8625,7 +8625,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":477 + /* "_pydevd_bundle/pydevd_cython.pyx":478 * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_locals, var_name) * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): # <<<<<<<<<<<<<< @@ -8634,21 +8634,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r */ } - /* "_pydevd_bundle/pydevd_cython.pyx":481 + /* "_pydevd_bundle/pydevd_cython.pyx":482 * if var_name.startswith(RETURN_VALUES_PREFIX): * dict_pop(frame.f_back.f_locals, var_name) * main_debugger.remove_return_values_flag = False # <<<<<<<<<<<<<< * except: * main_debugger.remove_return_values_flag = False */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "_pydevd_bundle/pydevd_cython.pyx":472 * if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): * frame.f_back.f_locals[RETURN_VALUES_PREFIX + name] = arg * if main_debugger.remove_return_values_flag: # <<<<<<<<<<<<<< - * # show return values was turned off, we should remove them from locals dict - * for var_name in dict_keys(frame.f_locals): + * # Showing return values was turned off, we should remove them from locals dict. + * # The values can be in the current frame or in the back one */ } @@ -8672,7 +8672,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":482 + /* "_pydevd_bundle/pydevd_cython.pyx":483 * dict_pop(frame.f_back.f_locals, var_name) * main_debugger.remove_return_values_flag = False * except: # <<<<<<<<<<<<<< @@ -8681,30 +8681,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.manage_return_values", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_4, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 482; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_4, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_14); - /* "_pydevd_bundle/pydevd_cython.pyx":483 + /* "_pydevd_bundle/pydevd_cython.pyx":484 * main_debugger.remove_return_values_flag = False * except: * main_debugger.remove_return_values_flag = False # <<<<<<<<<<<<<< * traceback.print_exc() * */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":484 + /* "_pydevd_bundle/pydevd_cython.pyx":485 * except: * main_debugger.remove_return_values_flag = False * traceback.print_exc() # <<<<<<<<<<<<<< * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) */ - __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); - __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; @@ -8718,10 +8718,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r } } if (__pyx_t_10) { - __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { - __pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} } __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; @@ -8781,7 +8781,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_14manage_r return __pyx_r; } -/* "_pydevd_bundle/pydevd_cython.pyx":487 +/* "_pydevd_bundle/pydevd_cython.pyx":488 * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * def trace_dispatch(self, frame, str event, arg): # <<<<<<<<<<<<<< @@ -8825,21 +8825,21 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_17trace_di case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "trace_dispatch") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "trace_dispatch") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; @@ -8856,13 +8856,13 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_17trace_di } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), (&PyString_Type), 1, "event", 1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_event), (&PyString_Type), 1, "event", 1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_dispatch(__pyx_self, __pyx_v_self, __pyx_v_frame, __pyx_v_event, __pyx_v_arg); /* function exit code */ @@ -8959,14 +8959,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_RefNannySetupContext("trace_dispatch", 0); __Pyx_INCREF(__pyx_v_frame); - /* "_pydevd_bundle/pydevd_cython.pyx":501 + /* "_pydevd_bundle/pydevd_cython.pyx":502 * # ENDIF * * main_debugger, filename, info, thread = self._args # <<<<<<<<<<<<<< * try: * # print 'frame trace_dispatch', frame.f_lineno, frame.f_code.co_name, event */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { PyObject* sequence = __pyx_t_1; @@ -8978,7 +8978,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 4)) { if (size > 4) __Pyx_RaiseTooManyValuesError(4); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -9001,7 +9001,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di Py_ssize_t i; PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_3,&__pyx_t_4,&__pyx_t_5}; for (i=0; i < 4; i++) { - PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(item); *(temps[i]) = item; } @@ -9011,7 +9011,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } else { Py_ssize_t index = -1; PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_3,&__pyx_t_4,&__pyx_t_5}; - __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; @@ -9020,7 +9020,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_unpacking_done; @@ -9028,11 +9028,11 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_L4_unpacking_done:; } - if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 501; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_main_debugger = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_filename = ((PyObject*)__pyx_t_3); @@ -9042,7 +9042,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_thread = __pyx_t_5; __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":502 + /* "_pydevd_bundle/pydevd_cython.pyx":503 * * main_debugger, filename, info, thread = self._args * try: # <<<<<<<<<<<<<< @@ -9051,7 +9051,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":504 + /* "_pydevd_bundle/pydevd_cython.pyx":505 * try: * # print 'frame trace_dispatch', frame.f_lineno, frame.f_code.co_name, event * info.is_tracing = True # <<<<<<<<<<<<<< @@ -9060,7 +9060,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_info->is_tracing = 1; - /* "_pydevd_bundle/pydevd_cython.pyx":505 + /* "_pydevd_bundle/pydevd_cython.pyx":506 * # print 'frame trace_dispatch', frame.f_lineno, frame.f_code.co_name, event * info.is_tracing = True * need_trace_return = False # <<<<<<<<<<<<<< @@ -9070,20 +9070,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __pyx_v_need_trace_return = Py_False; - /* "_pydevd_bundle/pydevd_cython.pyx":507 + /* "_pydevd_bundle/pydevd_cython.pyx":508 * need_trace_return = False * * if main_debugger._finish_debugging_session: # <<<<<<<<<<<<<< * return None * */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":508 + /* "_pydevd_bundle/pydevd_cython.pyx":509 * * if main_debugger._finish_debugging_session: * return None # <<<<<<<<<<<<<< @@ -9095,7 +9095,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_r = Py_None; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":507 + /* "_pydevd_bundle/pydevd_cython.pyx":508 * need_trace_return = False * * if main_debugger._finish_debugging_session: # <<<<<<<<<<<<<< @@ -9104,36 +9104,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":510 + /* "_pydevd_bundle/pydevd_cython.pyx":511 * return None * * if event == 'call' and main_debugger.signature_factory: # <<<<<<<<<<<<<< * need_trace_return = send_signature_call_trace(main_debugger, frame, filename) * if event == 'return' and main_debugger.signature_factory: */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_10 = (__pyx_t_9 != 0); if (__pyx_t_10) { } else { __pyx_t_8 = __pyx_t_10; goto __pyx_L10_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = __pyx_t_10; __pyx_L10_bool_binop_done:; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":511 + /* "_pydevd_bundle/pydevd_cython.pyx":512 * * if event == 'call' and main_debugger.signature_factory: * need_trace_return = send_signature_call_trace(main_debugger, frame, filename) # <<<<<<<<<<<<<< * if event == 'return' and main_debugger.signature_factory: * send_signature_return_trace(main_debugger, frame, filename, arg) */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_send_signature_call_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_send_signature_call_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -9147,7 +9147,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -9161,14 +9161,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_11, __pyx_v_filename); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_need_trace_return, __pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":510 + /* "_pydevd_bundle/pydevd_cython.pyx":511 * return None * * if event == 'call' and main_debugger.signature_factory: # <<<<<<<<<<<<<< @@ -9177,36 +9177,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":512 + /* "_pydevd_bundle/pydevd_cython.pyx":513 * if event == 'call' and main_debugger.signature_factory: * need_trace_return = send_signature_call_trace(main_debugger, frame, filename) * if event == 'return' and main_debugger.signature_factory: # <<<<<<<<<<<<<< * send_signature_return_trace(main_debugger, frame, filename, arg) * */ - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L13_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_signature_factory); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 512; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L13_bool_binop_done:; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":513 + /* "_pydevd_bundle/pydevd_cython.pyx":514 * need_trace_return = send_signature_call_trace(main_debugger, frame, filename) * if event == 'return' and main_debugger.signature_factory: * send_signature_return_trace(main_debugger, frame, filename, arg) # <<<<<<<<<<<<<< * * plugin_manager = main_debugger.plugin */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_send_signature_return_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_send_signature_return_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = NULL; __pyx_t_11 = 0; @@ -9220,7 +9220,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_4 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -9237,13 +9237,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_11, __pyx_v_arg); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 513; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":512 + /* "_pydevd_bundle/pydevd_cython.pyx":513 * if event == 'call' and main_debugger.signature_factory: * need_trace_return = send_signature_call_trace(main_debugger, frame, filename) * if event == 'return' and main_debugger.signature_factory: # <<<<<<<<<<<<<< @@ -9252,53 +9252,53 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":515 + /* "_pydevd_bundle/pydevd_cython.pyx":516 * send_signature_return_trace(main_debugger, frame, filename, arg) * * plugin_manager = main_debugger.plugin # <<<<<<<<<<<<<< * * is_exception_event = event == 'exception' */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_plugin); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_plugin); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 516; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_plugin_manager = __pyx_t_1; __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":517 + /* "_pydevd_bundle/pydevd_cython.pyx":518 * plugin_manager = main_debugger.plugin * * is_exception_event = event == 'exception' # <<<<<<<<<<<<<< * has_exception_breakpoints = main_debugger.break_on_caught_exceptions or main_debugger.has_plugin_exception_breaks * */ - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_v_is_exception_event = __pyx_t_8; - /* "_pydevd_bundle/pydevd_cython.pyx":518 + /* "_pydevd_bundle/pydevd_cython.pyx":519 * * is_exception_event = event == 'exception' * has_exception_breakpoints = main_debugger.break_on_caught_exceptions or main_debugger.has_plugin_exception_breaks # <<<<<<<<<<<<<< * * if is_exception_event: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_caught_exceptions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_break_on_caught_exceptions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L15_bool_binop_done; } - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_exception_breaks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L15_bool_binop_done:; __pyx_v_has_exception_breakpoints = __pyx_t_8; - /* "_pydevd_bundle/pydevd_cython.pyx":520 + /* "_pydevd_bundle/pydevd_cython.pyx":521 * has_exception_breakpoints = main_debugger.break_on_caught_exceptions or main_debugger.has_plugin_exception_breaks * * if is_exception_event: # <<<<<<<<<<<<<< @@ -9308,7 +9308,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_8 = (__pyx_v_is_exception_event != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":521 + /* "_pydevd_bundle/pydevd_cython.pyx":522 * * if is_exception_event: * if has_exception_breakpoints: # <<<<<<<<<<<<<< @@ -9318,14 +9318,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_8 = (__pyx_v_has_exception_breakpoints != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":522 + /* "_pydevd_bundle/pydevd_cython.pyx":523 * if is_exception_event: * if has_exception_breakpoints: * flag, frame = self.should_stop_on_exception(frame, event, arg) # <<<<<<<<<<<<<< * if flag: * self.handle_exception(frame, event, arg) */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_stop_on_exception); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_stop_on_exception); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -9339,7 +9339,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -9353,7 +9353,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_11, __pyx_v_arg); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; @@ -9367,7 +9367,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -9380,15 +9380,15 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(__pyx_t_3); #else - __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { Py_ssize_t index = -1; - __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; @@ -9396,7 +9396,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GOTREF(__pyx_t_5); index = 1; __pyx_t_3 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L19_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L20_unpacking_done; @@ -9404,7 +9404,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_L20_unpacking_done:; } __pyx_v_flag = __pyx_t_5; @@ -9412,24 +9412,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF_SET(__pyx_v_frame, __pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":523 + /* "_pydevd_bundle/pydevd_cython.pyx":524 * if has_exception_breakpoints: * flag, frame = self.should_stop_on_exception(frame, event, arg) * if flag: # <<<<<<<<<<<<<< * self.handle_exception(frame, event, arg) * return self.trace_dispatch */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 523; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L6_error;} if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":524 + /* "_pydevd_bundle/pydevd_cython.pyx":525 * flag, frame = self.should_stop_on_exception(frame, event, arg) * if flag: * self.handle_exception(frame, event, arg) # <<<<<<<<<<<<<< * return self.trace_dispatch * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_handle_exception); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_handle_exception); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; __pyx_t_11 = 0; @@ -9443,7 +9443,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_4 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -9457,13 +9457,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_11, __pyx_v_arg); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":525 + /* "_pydevd_bundle/pydevd_cython.pyx":526 * if flag: * self.handle_exception(frame, event, arg) * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -9471,13 +9471,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * elif event not in ('line', 'call', 'return'): */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 526; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":523 + /* "_pydevd_bundle/pydevd_cython.pyx":524 * if has_exception_breakpoints: * flag, frame = self.should_stop_on_exception(frame, event, arg) * if flag: # <<<<<<<<<<<<<< @@ -9486,7 +9486,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":521 + /* "_pydevd_bundle/pydevd_cython.pyx":522 * * if is_exception_event: * if has_exception_breakpoints: # <<<<<<<<<<<<<< @@ -9495,7 +9495,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":520 + /* "_pydevd_bundle/pydevd_cython.pyx":521 * has_exception_breakpoints = main_debugger.break_on_caught_exceptions or main_debugger.has_plugin_exception_breaks * * if is_exception_event: # <<<<<<<<<<<<<< @@ -9505,7 +9505,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di goto __pyx_L17; } - /* "_pydevd_bundle/pydevd_cython.pyx":527 + /* "_pydevd_bundle/pydevd_cython.pyx":528 * return self.trace_dispatch * * elif event not in ('line', 'call', 'return'): # <<<<<<<<<<<<<< @@ -9514,21 +9514,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_v_event); __pyx_t_12 = __pyx_v_event; - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_NE)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_NE)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_10 = (__pyx_t_9 != 0); if (__pyx_t_10) { } else { __pyx_t_8 = __pyx_t_10; goto __pyx_L22_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_call, Py_NE)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_call, Py_NE)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L22_bool_binop_done; } - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_NE)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_NE)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_10 = (__pyx_t_9 != 0); __pyx_t_8 = __pyx_t_10; __pyx_L22_bool_binop_done:; @@ -9536,7 +9536,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_10 = (__pyx_t_8 != 0); if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":529 + /* "_pydevd_bundle/pydevd_cython.pyx":530 * elif event not in ('line', 'call', 'return'): * #I believe this can only happen in jython on some frontiers on jython and java code, which we don't want to trace. * return None # <<<<<<<<<<<<<< @@ -9548,7 +9548,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_r = Py_None; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":527 + /* "_pydevd_bundle/pydevd_cython.pyx":528 * return self.trace_dispatch * * elif event not in ('line', 'call', 'return'): # <<<<<<<<<<<<<< @@ -9558,7 +9558,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } __pyx_L17:; - /* "_pydevd_bundle/pydevd_cython.pyx":531 + /* "_pydevd_bundle/pydevd_cython.pyx":532 * return None * * stop_frame = info.pydev_step_stop # <<<<<<<<<<<<<< @@ -9570,7 +9570,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_stop_frame = __pyx_t_1; __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":532 + /* "_pydevd_bundle/pydevd_cython.pyx":533 * * stop_frame = info.pydev_step_stop * step_cmd = info.pydev_step_cmd # <<<<<<<<<<<<<< @@ -9580,7 +9580,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_13 = __pyx_v_info->pydev_step_cmd; __pyx_v_step_cmd = __pyx_t_13; - /* "_pydevd_bundle/pydevd_cython.pyx":534 + /* "_pydevd_bundle/pydevd_cython.pyx":535 * step_cmd = info.pydev_step_cmd * * if is_exception_event: # <<<<<<<<<<<<<< @@ -9590,7 +9590,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_10 = (__pyx_v_is_exception_event != 0); if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":535 + /* "_pydevd_bundle/pydevd_cython.pyx":536 * * if is_exception_event: * breakpoints_for_file = None # <<<<<<<<<<<<<< @@ -9600,14 +9600,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_None); __pyx_v_breakpoints_for_file = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":536 + /* "_pydevd_bundle/pydevd_cython.pyx":537 * if is_exception_event: * breakpoints_for_file = None * if stop_frame and stop_frame is not frame and step_cmd is CMD_STEP_OVER and \ # <<<<<<<<<<<<<< * arg[0] in (StopIteration, GeneratorExit) and arg[2] is None: * info.pydev_step_cmd = CMD_STEP_INTO */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_stop_frame); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_stop_frame); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} if (__pyx_t_8) { } else { __pyx_t_10 = __pyx_t_8; @@ -9620,9 +9620,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_10 = __pyx_t_9; goto __pyx_L27_bool_binop_done; } - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = (__pyx_t_1 == __pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -9634,25 +9634,25 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di goto __pyx_L27_bool_binop_done; } - /* "_pydevd_bundle/pydevd_cython.pyx":537 + /* "_pydevd_bundle/pydevd_cython.pyx":538 * breakpoints_for_file = None * if stop_frame and stop_frame is not frame and step_cmd is CMD_STEP_OVER and \ * arg[0] in (StopIteration, GeneratorExit) and arg[2] is None: # <<<<<<<<<<<<<< * info.pydev_step_cmd = CMD_STEP_INTO * info.pydev_step_stop = None */ - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;}; + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;}; __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_builtin_StopIteration, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_builtin_StopIteration, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (!__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L32_bool_binop_done; } - __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_builtin_GeneratorExit, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_builtin_GeneratorExit, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L32_bool_binop_done:; @@ -9663,7 +9663,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_10 = __pyx_t_9; goto __pyx_L27_bool_binop_done; } - __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L6_error;}; + __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_arg, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = (__pyx_t_3 == Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -9671,7 +9671,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_10 = __pyx_t_8; __pyx_L27_bool_binop_done:; - /* "_pydevd_bundle/pydevd_cython.pyx":536 + /* "_pydevd_bundle/pydevd_cython.pyx":537 * if is_exception_event: * breakpoints_for_file = None * if stop_frame and stop_frame is not frame and step_cmd is CMD_STEP_OVER and \ # <<<<<<<<<<<<<< @@ -9680,20 +9680,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":538 + /* "_pydevd_bundle/pydevd_cython.pyx":539 * if stop_frame and stop_frame is not frame and step_cmd is CMD_STEP_OVER and \ * arg[0] in (StopIteration, GeneratorExit) and arg[2] is None: * info.pydev_step_cmd = CMD_STEP_INTO # <<<<<<<<<<<<<< * info.pydev_step_stop = None * else: */ - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_info->pydev_step_cmd = __pyx_t_13; - /* "_pydevd_bundle/pydevd_cython.pyx":539 + /* "_pydevd_bundle/pydevd_cython.pyx":540 * arg[0] in (StopIteration, GeneratorExit) and arg[2] is None: * info.pydev_step_cmd = CMD_STEP_INTO * info.pydev_step_stop = None # <<<<<<<<<<<<<< @@ -9706,7 +9706,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_v_info->pydev_step_stop); __pyx_v_info->pydev_step_stop = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":536 + /* "_pydevd_bundle/pydevd_cython.pyx":537 * if is_exception_event: * breakpoints_for_file = None * if stop_frame and stop_frame is not frame and step_cmd is CMD_STEP_OVER and \ # <<<<<<<<<<<<<< @@ -9715,7 +9715,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":534 + /* "_pydevd_bundle/pydevd_cython.pyx":535 * step_cmd = info.pydev_step_cmd * * if is_exception_event: # <<<<<<<<<<<<<< @@ -9725,7 +9725,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di goto __pyx_L25; } - /* "_pydevd_bundle/pydevd_cython.pyx":547 + /* "_pydevd_bundle/pydevd_cython.pyx":548 * # Note: this is especially troublesome when we're skipping code with the * # @DontTrace comment. * if stop_frame is frame and event is 'return' and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): # <<<<<<<<<<<<<< @@ -9748,28 +9748,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di goto __pyx_L35_bool_binop_done; } __pyx_t_13 = __pyx_v_step_cmd; - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L38_bool_binop_done; } - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L38_bool_binop_done:; @@ -9778,43 +9778,43 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_L35_bool_binop_done:; if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":548 + /* "_pydevd_bundle/pydevd_cython.pyx":549 * # @DontTrace comment. * if stop_frame is frame and event is 'return' and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): * if not frame.f_code.co_flags & CO_GENERATOR: # <<<<<<<<<<<<<< * info.pydev_step_cmd = CMD_STEP_INTO * info.pydev_step_stop = None */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_flags); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CO_GENERATOR); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CO_GENERATOR); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyNumber_And(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyNumber_And(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_9 = ((!__pyx_t_10) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":549 + /* "_pydevd_bundle/pydevd_cython.pyx":550 * if stop_frame is frame and event is 'return' and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): * if not frame.f_code.co_flags & CO_GENERATOR: * info.pydev_step_cmd = CMD_STEP_INTO # <<<<<<<<<<<<<< * info.pydev_step_stop = None * */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_info->pydev_step_cmd = __pyx_t_13; - /* "_pydevd_bundle/pydevd_cython.pyx":550 + /* "_pydevd_bundle/pydevd_cython.pyx":551 * if not frame.f_code.co_flags & CO_GENERATOR: * info.pydev_step_cmd = CMD_STEP_INTO * info.pydev_step_stop = None # <<<<<<<<<<<<<< @@ -9827,7 +9827,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_v_info->pydev_step_stop); __pyx_v_info->pydev_step_stop = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":548 + /* "_pydevd_bundle/pydevd_cython.pyx":549 * # @DontTrace comment. * if stop_frame is frame and event is 'return' and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): * if not frame.f_code.co_flags & CO_GENERATOR: # <<<<<<<<<<<<<< @@ -9836,7 +9836,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":547 + /* "_pydevd_bundle/pydevd_cython.pyx":548 * # Note: this is especially troublesome when we're skipping code with the * # @DontTrace comment. * if stop_frame is frame and event is 'return' and step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER): # <<<<<<<<<<<<<< @@ -9845,16 +9845,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":552 + /* "_pydevd_bundle/pydevd_cython.pyx":553 * info.pydev_step_stop = None * * breakpoints_for_file = main_debugger.breakpoints.get(filename) # <<<<<<<<<<<<<< * * can_skip = False */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_breakpoints); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 552; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_breakpoints); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 552; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -9868,16 +9868,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_3) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_filename); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 552; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_filename); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); } else { - __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 552; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL; __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_filename); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 552; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } @@ -9885,7 +9885,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_breakpoints_for_file = __pyx_t_4; __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":554 + /* "_pydevd_bundle/pydevd_cython.pyx":555 * breakpoints_for_file = main_debugger.breakpoints.get(filename) * * can_skip = False # <<<<<<<<<<<<<< @@ -9894,25 +9894,25 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_can_skip = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":556 + /* "_pydevd_bundle/pydevd_cython.pyx":557 * can_skip = False * * if info.pydev_state == STATE_RUN: # <<<<<<<<<<<<<< * #we can skip if: * #- we have no stop marked */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_RUN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_RUN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":560 + /* "_pydevd_bundle/pydevd_cython.pyx":561 * #- we have no stop marked * #- we should make a step return/step over and we're not in the current frame * can_skip = (step_cmd == -1 and stop_frame is None)\ # <<<<<<<<<<<<<< @@ -9933,7 +9933,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } __pyx_L43_next_or:; - /* "_pydevd_bundle/pydevd_cython.pyx":561 + /* "_pydevd_bundle/pydevd_cython.pyx":562 * #- we should make a step return/step over and we're not in the current frame * can_skip = (step_cmd == -1 and stop_frame is None)\ * or (step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER) and stop_frame is not frame) # <<<<<<<<<<<<<< @@ -9941,28 +9941,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if can_skip and plugin_manager is not None and main_debugger.has_plugin_line_breaks: */ __pyx_t_13 = __pyx_v_step_cmd; - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_10) { } else { __pyx_t_8 = __pyx_t_10; goto __pyx_L46_bool_binop_done; } - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_t_13); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 562; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_8 = __pyx_t_10; __pyx_L46_bool_binop_done:; @@ -9978,7 +9978,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_L42_bool_binop_done:; __pyx_v_can_skip = __pyx_t_9; - /* "_pydevd_bundle/pydevd_cython.pyx":556 + /* "_pydevd_bundle/pydevd_cython.pyx":557 * can_skip = False * * if info.pydev_state == STATE_RUN: # <<<<<<<<<<<<<< @@ -9987,7 +9987,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":563 + /* "_pydevd_bundle/pydevd_cython.pyx":564 * or (step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER) and stop_frame is not frame) * * if can_skip and plugin_manager is not None and main_debugger.has_plugin_line_breaks: # <<<<<<<<<<<<<< @@ -10007,22 +10007,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_9 = __pyx_t_10; goto __pyx_L49_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __pyx_t_10; __pyx_L49_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":564 + /* "_pydevd_bundle/pydevd_cython.pyx":565 * * if can_skip and plugin_manager is not None and main_debugger.has_plugin_line_breaks: * can_skip = not plugin_manager.can_not_skip(main_debugger, self, frame) # <<<<<<<<<<<<<< * * if can_skip and main_debugger.show_return_values: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_can_not_skip); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_can_not_skip); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 565; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -10036,7 +10036,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 565; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -10050,15 +10050,15 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_3, 2+__pyx_t_11, __pyx_v_frame); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 565; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 564; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 565; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_can_skip = (!__pyx_t_9); - /* "_pydevd_bundle/pydevd_cython.pyx":563 + /* "_pydevd_bundle/pydevd_cython.pyx":564 * or (step_cmd in (CMD_STEP_RETURN, CMD_STEP_OVER) and stop_frame is not frame) * * if can_skip and plugin_manager is not None and main_debugger.has_plugin_line_breaks: # <<<<<<<<<<<<<< @@ -10067,12 +10067,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":566 + /* "_pydevd_bundle/pydevd_cython.pyx":567 * can_skip = not plugin_manager.can_not_skip(main_debugger, self, frame) * * if can_skip and main_debugger.show_return_values: # <<<<<<<<<<<<<< * # trace function for showing return values after step over - * if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: + * if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: */ __pyx_t_10 = (__pyx_v_can_skip != 0); if (__pyx_t_10) { @@ -10080,104 +10080,111 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_9 = __pyx_t_10; goto __pyx_L53_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 567; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 567; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __pyx_t_10; __pyx_L53_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":568 + /* "_pydevd_bundle/pydevd_cython.pyx":569 * if can_skip and main_debugger.show_return_values: * # trace function for showing return values after step over - * if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: # <<<<<<<<<<<<<< + * if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: # <<<<<<<<<<<<<< * can_skip = False * */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_10) { } else { __pyx_t_9 = __pyx_t_10; goto __pyx_L56_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = (__pyx_t_10 != 0); + if (__pyx_t_8) { + } else { + __pyx_t_9 = __pyx_t_8; + goto __pyx_L56_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_v_info->pydev_step_stop, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_v_info->pydev_step_stop, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 569; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_9 = __pyx_t_10; + __pyx_t_9 = __pyx_t_8; __pyx_L56_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":569 + /* "_pydevd_bundle/pydevd_cython.pyx":570 * # trace function for showing return values after step over - * if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: + * if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: * can_skip = False # <<<<<<<<<<<<<< * * # Let's check to see if we are in a function that has a breakpoint. If we don't have a breakpoint, */ __pyx_v_can_skip = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":568 + /* "_pydevd_bundle/pydevd_cython.pyx":569 * if can_skip and main_debugger.show_return_values: * # trace function for showing return values after step over - * if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: # <<<<<<<<<<<<<< + * if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: # <<<<<<<<<<<<<< * can_skip = False * */ } - /* "_pydevd_bundle/pydevd_cython.pyx":566 + /* "_pydevd_bundle/pydevd_cython.pyx":567 * can_skip = not plugin_manager.can_not_skip(main_debugger, self, frame) * * if can_skip and main_debugger.show_return_values: # <<<<<<<<<<<<<< * # trace function for showing return values after step over - * if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: + * if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: */ } - /* "_pydevd_bundle/pydevd_cython.pyx":575 + /* "_pydevd_bundle/pydevd_cython.pyx":576 * #also, after we hit a breakpoint and go to some other debugging state, we have to force the set trace anyway, * #so, that's why the additional checks are there. * if not breakpoints_for_file: # <<<<<<<<<<<<<< * if can_skip: * if has_exception_breakpoints: */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoints_for_file); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoints_for_file); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 576; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = ((!__pyx_t_9) != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":576 + /* "_pydevd_bundle/pydevd_cython.pyx":577 * #so, that's why the additional checks are there. * if not breakpoints_for_file: * if can_skip: # <<<<<<<<<<<<<< * if has_exception_breakpoints: * return self.trace_exception */ - __pyx_t_10 = (__pyx_v_can_skip != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_v_can_skip != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":577 + /* "_pydevd_bundle/pydevd_cython.pyx":578 * if not breakpoints_for_file: * if can_skip: * if has_exception_breakpoints: # <<<<<<<<<<<<<< * return self.trace_exception * else: */ - __pyx_t_10 = (__pyx_v_has_exception_breakpoints != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_v_has_exception_breakpoints != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":578 + /* "_pydevd_bundle/pydevd_cython.pyx":579 * if can_skip: * if has_exception_breakpoints: * return self.trace_exception # <<<<<<<<<<<<<< @@ -10185,13 +10192,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if need_trace_return: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_exception); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_exception); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 579; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":577 + /* "_pydevd_bundle/pydevd_cython.pyx":578 * if not breakpoints_for_file: * if can_skip: * if has_exception_breakpoints: # <<<<<<<<<<<<<< @@ -10200,7 +10207,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":580 + /* "_pydevd_bundle/pydevd_cython.pyx":581 * return self.trace_exception * else: * if need_trace_return: # <<<<<<<<<<<<<< @@ -10208,10 +10215,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * else: */ /*else*/ { - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_need_trace_return); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 580; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_need_trace_return); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":581 + /* "_pydevd_bundle/pydevd_cython.pyx":582 * else: * if need_trace_return: * return self.trace_return # <<<<<<<<<<<<<< @@ -10219,13 +10226,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * return None */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_return); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_return); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 582; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":580 + /* "_pydevd_bundle/pydevd_cython.pyx":581 * return self.trace_exception * else: * if need_trace_return: # <<<<<<<<<<<<<< @@ -10234,7 +10241,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":583 + /* "_pydevd_bundle/pydevd_cython.pyx":584 * return self.trace_return * else: * return None # <<<<<<<<<<<<<< @@ -10249,7 +10256,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } - /* "_pydevd_bundle/pydevd_cython.pyx":576 + /* "_pydevd_bundle/pydevd_cython.pyx":577 * #so, that's why the additional checks are there. * if not breakpoints_for_file: * if can_skip: # <<<<<<<<<<<<<< @@ -10258,17 +10265,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":575 + /* "_pydevd_bundle/pydevd_cython.pyx":576 * #also, after we hit a breakpoint and go to some other debugging state, we have to force the set trace anyway, * #so, that's why the additional checks are there. * if not breakpoints_for_file: # <<<<<<<<<<<<<< * if can_skip: * if has_exception_breakpoints: */ - goto __pyx_L58; + goto __pyx_L59; } - /* "_pydevd_bundle/pydevd_cython.pyx":587 + /* "_pydevd_bundle/pydevd_cython.pyx":588 * else: * #checks the breakpoint to see if there is a context match in some function * curr_func_name = frame.f_code.co_name # <<<<<<<<<<<<<< @@ -10276,16 +10283,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * #global context is set with an empty name */ /*else*/ { - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 587; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_co_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 587; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_co_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 587; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_v_curr_func_name = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":590 + /* "_pydevd_bundle/pydevd_cython.pyx":591 * * #global context is set with an empty name * if curr_func_name in ('?', ''): # <<<<<<<<<<<<<< @@ -10294,22 +10301,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_v_curr_func_name); __pyx_t_12 = __pyx_v_curr_func_name; - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 590; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_8 = (__pyx_t_9 != 0); - if (!__pyx_t_8) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 591; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_10 = (__pyx_t_9 != 0); + if (!__pyx_t_10) { } else { - __pyx_t_10 = __pyx_t_8; - goto __pyx_L63_bool_binop_done; + __pyx_t_8 = __pyx_t_10; + goto __pyx_L64_bool_binop_done; } - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 590; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_9 = (__pyx_t_8 != 0); - __pyx_t_10 = __pyx_t_9; - __pyx_L63_bool_binop_done:; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 591; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = __pyx_t_9; + __pyx_L64_bool_binop_done:; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":591 + /* "_pydevd_bundle/pydevd_cython.pyx":592 * #global context is set with an empty name * if curr_func_name in ('?', ''): * curr_func_name = '' # <<<<<<<<<<<<<< @@ -10319,7 +10326,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_kp_s_); __Pyx_DECREF_SET(__pyx_v_curr_func_name, __pyx_kp_s_); - /* "_pydevd_bundle/pydevd_cython.pyx":590 + /* "_pydevd_bundle/pydevd_cython.pyx":591 * * #global context is set with an empty name * if curr_func_name in ('?', ''): # <<<<<<<<<<<<<< @@ -10328,14 +10335,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":593 + /* "_pydevd_bundle/pydevd_cython.pyx":594 * curr_func_name = '' * * for breakpoint in dict_iter_values(breakpoints_for_file): #jython does not support itervalues() # <<<<<<<<<<<<<< * #will match either global or some function * if breakpoint.func_name in ('None', curr_func_name): */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_iter_values); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_iter_values); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { @@ -10348,16 +10355,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_5) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_breakpoints_for_file); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_breakpoints_for_file); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_breakpoints_for_file); __Pyx_GIVEREF(__pyx_v_breakpoints_for_file); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_breakpoints_for_file); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } @@ -10366,9 +10373,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_11 = 0; __pyx_t_14 = NULL; } else { - __pyx_t_11 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_11 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_14 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_14 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; for (;;) { @@ -10376,17 +10383,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); #endif } else { if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON - __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_11); __Pyx_INCREF(__pyx_t_3); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} #else - __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); #endif } @@ -10396,7 +10403,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 594; __pyx_clineno = __LINE__; goto __pyx_L6_error;} } break; } @@ -10405,38 +10412,38 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF_SET(__pyx_v_breakpoint, __pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":595 + /* "_pydevd_bundle/pydevd_cython.pyx":596 * for breakpoint in dict_iter_values(breakpoints_for_file): #jython does not support itervalues() * #will match either global or some function * if breakpoint.func_name in ('None', curr_func_name): # <<<<<<<<<<<<<< * break * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_func_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 595; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_func_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 596; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_None, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 595; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - if (!__pyx_t_10) { + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_None, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 596; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + if (!__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L68_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L69_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_v_curr_func_name, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 595; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - __pyx_t_9 = __pyx_t_10; - __pyx_L68_bool_binop_done:; + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_v_curr_func_name, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 596; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_9 = __pyx_t_8; + __pyx_L69_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":596 + /* "_pydevd_bundle/pydevd_cython.pyx":597 * #will match either global or some function * if breakpoint.func_name in ('None', curr_func_name): * break # <<<<<<<<<<<<<< * * else: # if we had some break, it won't get here (so, that's a context that we want to skip) */ - goto __pyx_L66_break; + goto __pyx_L67_break; - /* "_pydevd_bundle/pydevd_cython.pyx":595 + /* "_pydevd_bundle/pydevd_cython.pyx":596 * for breakpoint in dict_iter_values(breakpoints_for_file): #jython does not support itervalues() * #will match either global or some function * if breakpoint.func_name in ('None', curr_func_name): # <<<<<<<<<<<<<< @@ -10445,7 +10452,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":593 + /* "_pydevd_bundle/pydevd_cython.pyx":594 * curr_func_name = '' * * for breakpoint in dict_iter_values(breakpoints_for_file): #jython does not support itervalues() # <<<<<<<<<<<<<< @@ -10455,27 +10462,27 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } /*else*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":599 + /* "_pydevd_bundle/pydevd_cython.pyx":600 * * else: # if we had some break, it won't get here (so, that's a context that we want to skip) * if can_skip: # <<<<<<<<<<<<<< * if has_exception_breakpoints: * return self.trace_exception */ - __pyx_t_10 = (__pyx_v_can_skip != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_v_can_skip != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":600 + /* "_pydevd_bundle/pydevd_cython.pyx":601 * else: # if we had some break, it won't get here (so, that's a context that we want to skip) * if can_skip: * if has_exception_breakpoints: # <<<<<<<<<<<<<< * return self.trace_exception * else: */ - __pyx_t_10 = (__pyx_v_has_exception_breakpoints != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_v_has_exception_breakpoints != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":601 + /* "_pydevd_bundle/pydevd_cython.pyx":602 * if can_skip: * if has_exception_breakpoints: * return self.trace_exception # <<<<<<<<<<<<<< @@ -10483,14 +10490,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if need_trace_return: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_exception); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_exception); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":600 + /* "_pydevd_bundle/pydevd_cython.pyx":601 * else: # if we had some break, it won't get here (so, that's a context that we want to skip) * if can_skip: * if has_exception_breakpoints: # <<<<<<<<<<<<<< @@ -10499,7 +10506,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":603 + /* "_pydevd_bundle/pydevd_cython.pyx":604 * return self.trace_exception * else: * if need_trace_return: # <<<<<<<<<<<<<< @@ -10507,10 +10514,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * else: */ /*else*/ { - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_need_trace_return); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; __pyx_clineno = __LINE__; goto __pyx_L6_error;} - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_need_trace_return); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 604; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":604 + /* "_pydevd_bundle/pydevd_cython.pyx":605 * else: * if need_trace_return: * return self.trace_return # <<<<<<<<<<<<<< @@ -10518,14 +10525,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * return None */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_return); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 604; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_return); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 605; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L5_return; - /* "_pydevd_bundle/pydevd_cython.pyx":603 + /* "_pydevd_bundle/pydevd_cython.pyx":604 * return self.trace_exception * else: * if need_trace_return: # <<<<<<<<<<<<<< @@ -10534,7 +10541,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":606 + /* "_pydevd_bundle/pydevd_cython.pyx":607 * return self.trace_return * else: * return None # <<<<<<<<<<<<<< @@ -10550,7 +10557,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } - /* "_pydevd_bundle/pydevd_cython.pyx":599 + /* "_pydevd_bundle/pydevd_cython.pyx":600 * * else: # if we had some break, it won't get here (so, that's a context that we want to skip) * if can_skip: # <<<<<<<<<<<<<< @@ -10560,21 +10567,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } - /* "_pydevd_bundle/pydevd_cython.pyx":593 + /* "_pydevd_bundle/pydevd_cython.pyx":594 * curr_func_name = '' * * for breakpoint in dict_iter_values(breakpoints_for_file): #jython does not support itervalues() # <<<<<<<<<<<<<< * #will match either global or some function * if breakpoint.func_name in ('None', curr_func_name): */ - __pyx_L66_break:; + __pyx_L67_break:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } - __pyx_L58:; + __pyx_L59:; } __pyx_L25:; - /* "_pydevd_bundle/pydevd_cython.pyx":612 + /* "_pydevd_bundle/pydevd_cython.pyx":613 * #print 'NOT skipped', frame.f_lineno, frame.f_code.co_name, event * * try: # <<<<<<<<<<<<<< @@ -10588,20 +10595,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_17); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":613 + /* "_pydevd_bundle/pydevd_cython.pyx":614 * * try: * line = frame.f_lineno # <<<<<<<<<<<<<< * flag = False * #return is not taken into account for breakpoint hit because we'd have a double-hit in this case */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_line = __pyx_t_13; - /* "_pydevd_bundle/pydevd_cython.pyx":614 + /* "_pydevd_bundle/pydevd_cython.pyx":615 * try: * line = frame.f_lineno * flag = False # <<<<<<<<<<<<<< @@ -10611,19 +10618,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_XDECREF_SET(__pyx_v_flag, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":618 + /* "_pydevd_bundle/pydevd_cython.pyx":619 * #(one for the line and the other for the return). * * stop_info = {} # <<<<<<<<<<<<<< * breakpoint = None * exist_result = False */ - __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 618; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 619; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_stop_info = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":619 + /* "_pydevd_bundle/pydevd_cython.pyx":620 * * stop_info = {} * breakpoint = None # <<<<<<<<<<<<<< @@ -10633,7 +10640,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_None); __Pyx_XDECREF_SET(__pyx_v_breakpoint, Py_None); - /* "_pydevd_bundle/pydevd_cython.pyx":620 + /* "_pydevd_bundle/pydevd_cython.pyx":621 * stop_info = {} * breakpoint = None * exist_result = False # <<<<<<<<<<<<<< @@ -10642,7 +10649,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_exist_result = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":621 + /* "_pydevd_bundle/pydevd_cython.pyx":622 * breakpoint = None * exist_result = False * stop = False # <<<<<<<<<<<<<< @@ -10652,7 +10659,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __pyx_v_stop = Py_False; - /* "_pydevd_bundle/pydevd_cython.pyx":622 + /* "_pydevd_bundle/pydevd_cython.pyx":623 * exist_result = False * stop = False * bp_type = None # <<<<<<<<<<<<<< @@ -10662,43 +10669,43 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_None); __pyx_v_bp_type = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":623 + /* "_pydevd_bundle/pydevd_cython.pyx":624 * stop = False * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ # <<<<<<<<<<<<<< * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_8 = ((!__pyx_t_9) != 0); - if (__pyx_t_8) { + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_10 = ((!__pyx_t_9) != 0); + if (__pyx_t_10) { } else { - __pyx_t_10 = __pyx_t_8; - goto __pyx_L83_bool_binop_done; + __pyx_t_8 = __pyx_t_10; + goto __pyx_L84_bool_binop_done; } - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_NE)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { } else { - __pyx_t_10 = __pyx_t_9; - goto __pyx_L83_bool_binop_done; + __pyx_t_8 = __pyx_t_9; + goto __pyx_L84_bool_binop_done; } - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_SUSPEND); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_SUSPEND); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_9) { } else { - __pyx_t_10 = __pyx_t_9; - goto __pyx_L83_bool_binop_done; + __pyx_t_8 = __pyx_t_9; + goto __pyx_L84_bool_binop_done; } - /* "_pydevd_bundle/pydevd_cython.pyx":624 + /* "_pydevd_bundle/pydevd_cython.pyx":625 * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ * and dict_contains(breakpoints_for_file, line): # <<<<<<<<<<<<<< @@ -10707,30 +10714,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_t_9 = (__pyx_v_breakpoints_for_file != Py_None); - /* "_pydevd_bundle/pydevd_cython.pyx":623 + /* "_pydevd_bundle/pydevd_cython.pyx":624 * stop = False * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ # <<<<<<<<<<<<<< * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] */ - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { } else { - __pyx_t_10 = __pyx_t_8; - goto __pyx_L83_bool_binop_done; + __pyx_t_8 = __pyx_t_10; + goto __pyx_L84_bool_binop_done; } - /* "_pydevd_bundle/pydevd_cython.pyx":624 + /* "_pydevd_bundle/pydevd_cython.pyx":625 * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ * and dict_contains(breakpoints_for_file, line): # <<<<<<<<<<<<<< * breakpoint = breakpoints_for_file[line] * new_frame = frame */ - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_contains); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_dict_contains); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = NULL; __pyx_t_11 = 0; @@ -10744,7 +10751,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_2 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -10755,37 +10762,37 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_11, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 624; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_10 = __pyx_t_8; - __pyx_L83_bool_binop_done:; + __pyx_t_8 = __pyx_t_10; + __pyx_L84_bool_binop_done:; - /* "_pydevd_bundle/pydevd_cython.pyx":623 + /* "_pydevd_bundle/pydevd_cython.pyx":624 * stop = False * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ # <<<<<<<<<<<<<< * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] */ - if (__pyx_t_10) { + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":625 + /* "_pydevd_bundle/pydevd_cython.pyx":626 * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] # <<<<<<<<<<<<<< * new_frame = frame * stop = True */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_breakpoints_for_file, __pyx_v_line, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L74_error;}; + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_breakpoints_for_file, __pyx_v_line, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 626; __pyx_clineno = __LINE__; goto __pyx_L75_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_breakpoint, __pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":626 + /* "_pydevd_bundle/pydevd_cython.pyx":627 * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] * new_frame = frame # <<<<<<<<<<<<<< @@ -10795,7 +10802,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_frame); __pyx_v_new_frame = __pyx_v_frame; - /* "_pydevd_bundle/pydevd_cython.pyx":627 + /* "_pydevd_bundle/pydevd_cython.pyx":628 * breakpoint = breakpoints_for_file[line] * new_frame = frame * stop = True # <<<<<<<<<<<<<< @@ -10805,54 +10812,54 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_stop, Py_True); - /* "_pydevd_bundle/pydevd_cython.pyx":628 + /* "_pydevd_bundle/pydevd_cython.pyx":629 * new_frame = frame * stop = True * if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): # <<<<<<<<<<<<<< * stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { } else { - __pyx_t_10 = __pyx_t_8; - goto __pyx_L89_bool_binop_done; + __pyx_t_8 = __pyx_t_10; + goto __pyx_L90_bool_binop_done; } - __pyx_t_8 = (__pyx_v_stop_frame == __pyx_v_frame); - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = (__pyx_v_stop_frame == __pyx_v_frame); + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { } else { - __pyx_t_10 = __pyx_t_9; - goto __pyx_L89_bool_binop_done; + __pyx_t_8 = __pyx_t_9; + goto __pyx_L90_bool_binop_done; } __Pyx_INCREF(__pyx_v_event); __pyx_t_12 = __pyx_v_event; - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_18 = (__pyx_t_8 != 0); + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_18 = (__pyx_t_10 != 0); if (!__pyx_t_18) { } else { __pyx_t_9 = __pyx_t_18; - goto __pyx_L92_bool_binop_done; + goto __pyx_L93_bool_binop_done; } - __pyx_t_18 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_18 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 628; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_8 = (__pyx_t_18 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L92_bool_binop_done:; + __pyx_t_18 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_18 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 629; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_10 = (__pyx_t_18 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L93_bool_binop_done:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_8 = (__pyx_t_9 != 0); - __pyx_t_10 = __pyx_t_8; - __pyx_L89_bool_binop_done:; - if (__pyx_t_10) { + __pyx_t_10 = (__pyx_t_9 != 0); + __pyx_t_8 = __pyx_t_10; + __pyx_L90_bool_binop_done:; + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":629 + /* "_pydevd_bundle/pydevd_cython.pyx":630 * stop = True * if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): * stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) # <<<<<<<<<<<<<< @@ -10862,7 +10869,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":628 + /* "_pydevd_bundle/pydevd_cython.pyx":629 * new_frame = frame * stop = True * if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): # <<<<<<<<<<<<<< @@ -10871,48 +10878,48 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":623 + /* "_pydevd_bundle/pydevd_cython.pyx":624 * stop = False * bp_type = None * if not flag and event != 'return' and info.pydev_state != STATE_SUSPEND and breakpoints_for_file is not None \ # <<<<<<<<<<<<<< * and dict_contains(breakpoints_for_file, line): * breakpoint = breakpoints_for_file[line] */ - goto __pyx_L82; + goto __pyx_L83; } - /* "_pydevd_bundle/pydevd_cython.pyx":630 + /* "_pydevd_bundle/pydevd_cython.pyx":631 * if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): * stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: # <<<<<<<<<<<<<< * result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args) * if result: */ - __pyx_t_8 = (__pyx_v_plugin_manager != Py_None); - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = (__pyx_v_plugin_manager != Py_None); + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { } else { - __pyx_t_10 = __pyx_t_9; - goto __pyx_L94_bool_binop_done; + __pyx_t_8 = __pyx_t_9; + goto __pyx_L95_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_has_plugin_line_breaks); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __pyx_t_9; - __pyx_L94_bool_binop_done:; - if (__pyx_t_10) { + __pyx_t_8 = __pyx_t_9; + __pyx_L95_bool_binop_done:; + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":631 + /* "_pydevd_bundle/pydevd_cython.pyx":632 * stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: * result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args) # <<<<<<<<<<<<<< * if result: * exist_result = True */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_get_breakpoint); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_get_breakpoint); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 632; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 632; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; __pyx_t_11 = 0; @@ -10926,7 +10933,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_5 = PyTuple_New(5+__pyx_t_11); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = PyTuple_New(5+__pyx_t_11); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 632; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_1) { __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __pyx_t_1 = NULL; @@ -10946,24 +10953,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 4+__pyx_t_11, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 632; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_result = __pyx_t_2; __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":632 + /* "_pydevd_bundle/pydevd_cython.pyx":633 * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: * result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args) * if result: # <<<<<<<<<<<<<< * exist_result = True * (flag, breakpoint, new_frame, bp_type) = result */ - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 632; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 633; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":633 + /* "_pydevd_bundle/pydevd_cython.pyx":634 * result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args) * if result: * exist_result = True # <<<<<<<<<<<<<< @@ -10972,7 +10979,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_exist_result = 1; - /* "_pydevd_bundle/pydevd_cython.pyx":634 + /* "_pydevd_bundle/pydevd_cython.pyx":635 * if result: * exist_result = True * (flag, breakpoint, new_frame, bp_type) = result # <<<<<<<<<<<<<< @@ -10989,7 +10996,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 4)) { if (size > 4) __Pyx_RaiseTooManyValuesError(4); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L75_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -11012,7 +11019,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di Py_ssize_t i; PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_3,&__pyx_t_5,&__pyx_t_4}; for (i=0; i < 4; i++) { - PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(item); *(temps[i]) = item; } @@ -11021,24 +11028,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } else { Py_ssize_t index = -1; PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_3,&__pyx_t_5,&__pyx_t_4}; - __pyx_t_1 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_1 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = Py_TYPE(__pyx_t_1)->tp_iternext; for (index=0; index < 4; index++) { - PyObject* item = __pyx_t_7(__pyx_t_1); if (unlikely(!item)) goto __pyx_L97_unpacking_failed; + PyObject* item = __pyx_t_7(__pyx_t_1); if (unlikely(!item)) goto __pyx_L98_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_1), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_1), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L98_unpacking_done; - __pyx_L97_unpacking_failed:; + goto __pyx_L99_unpacking_done; + __pyx_L98_unpacking_failed:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_L98_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_L99_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_flag, __pyx_t_2); __pyx_t_2 = 0; @@ -11049,7 +11056,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF_SET(__pyx_v_bp_type, __pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":632 + /* "_pydevd_bundle/pydevd_cython.pyx":633 * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: * result = plugin_manager.get_breakpoint(main_debugger, self, frame, event, self._args) * if result: # <<<<<<<<<<<<<< @@ -11058,7 +11065,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":630 + /* "_pydevd_bundle/pydevd_cython.pyx":631 * if step_cmd == CMD_STEP_OVER and stop_frame is frame and event in ('line', 'return'): * stop = False #we don't stop on breakpoint if we have to stop by step-over (it will be processed later) * elif plugin_manager is not None and main_debugger.has_plugin_line_breaks: # <<<<<<<<<<<<<< @@ -11066,60 +11073,60 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if result: */ } - __pyx_L82:; + __pyx_L83:; - /* "_pydevd_bundle/pydevd_cython.pyx":636 + /* "_pydevd_bundle/pydevd_cython.pyx":637 * (flag, breakpoint, new_frame, bp_type) = result * * if breakpoint: # <<<<<<<<<<<<<< * #ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint * # lets do the conditional stuff here */ - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoint); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_breakpoint); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":639 + /* "_pydevd_bundle/pydevd_cython.pyx":640 * #ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint * # lets do the conditional stuff here * if stop or exist_result: # <<<<<<<<<<<<<< * condition = breakpoint.condition * if condition is not None: */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 639; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 640; __pyx_clineno = __LINE__; goto __pyx_L75_error;} if (!__pyx_t_9) { } else { - __pyx_t_10 = __pyx_t_9; - goto __pyx_L101_bool_binop_done; + __pyx_t_8 = __pyx_t_9; + goto __pyx_L102_bool_binop_done; } __pyx_t_9 = (__pyx_v_exist_result != 0); - __pyx_t_10 = __pyx_t_9; - __pyx_L101_bool_binop_done:; - if (__pyx_t_10) { + __pyx_t_8 = __pyx_t_9; + __pyx_L102_bool_binop_done:; + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":640 + /* "_pydevd_bundle/pydevd_cython.pyx":641 * # lets do the conditional stuff here * if stop or exist_result: * condition = breakpoint.condition # <<<<<<<<<<<<<< * if condition is not None: * try: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_condition); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 640; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_condition); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 641; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_condition = __pyx_t_4; __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":641 + /* "_pydevd_bundle/pydevd_cython.pyx":642 * if stop or exist_result: * condition = breakpoint.condition * if condition is not None: # <<<<<<<<<<<<<< * try: * val = eval(condition, new_frame.f_globals, new_frame.f_locals) */ - __pyx_t_10 = (__pyx_v_condition != Py_None); - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = (__pyx_v_condition != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":642 + /* "_pydevd_bundle/pydevd_cython.pyx":643 * condition = breakpoint.condition * if condition is not None: * try: # <<<<<<<<<<<<<< @@ -11133,20 +11140,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_21); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":643 + /* "_pydevd_bundle/pydevd_cython.pyx":644 * if condition is not None: * try: * val = eval(condition, new_frame.f_globals, new_frame.f_locals) # <<<<<<<<<<<<<< * if not val: * return self.trace_dispatch */ - if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} } - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_globals); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} + if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_globals); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} __Pyx_GOTREF(__pyx_t_4); - if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} + if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_condition); __Pyx_GIVEREF(__pyx_v_condition); @@ -11157,24 +11164,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_5); __pyx_t_4 = 0; __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_eval, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L104_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_eval, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L105_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_val = __pyx_t_5; __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":644 + /* "_pydevd_bundle/pydevd_cython.pyx":645 * try: * val = eval(condition, new_frame.f_globals, new_frame.f_locals) * if not val: # <<<<<<<<<<<<<< * return self.trace_dispatch * */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_val); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L104_error;} - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_val); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L105_error;} + __pyx_t_8 = ((!__pyx_t_9) != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":645 + /* "_pydevd_bundle/pydevd_cython.pyx":646 * val = eval(condition, new_frame.f_globals, new_frame.f_locals) * if not val: * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -11182,13 +11189,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * except: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L104_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 646; __pyx_clineno = __LINE__; goto __pyx_L105_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_r = __pyx_t_5; __pyx_t_5 = 0; - goto __pyx_L108_try_return; + goto __pyx_L109_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":644 + /* "_pydevd_bundle/pydevd_cython.pyx":645 * try: * val = eval(condition, new_frame.f_globals, new_frame.f_locals) * if not val: # <<<<<<<<<<<<<< @@ -11197,7 +11204,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":642 + /* "_pydevd_bundle/pydevd_cython.pyx":643 * condition = breakpoint.condition * if condition is not None: * try: # <<<<<<<<<<<<<< @@ -11208,8 +11215,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; - goto __pyx_L111_try_end; - __pyx_L104_error:; + goto __pyx_L112_try_end; + __pyx_L105_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -11218,7 +11225,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":647 + /* "_pydevd_bundle/pydevd_cython.pyx":648 * return self.trace_dispatch * * except: # <<<<<<<<<<<<<< @@ -11227,50 +11234,50 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_3, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_3, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_4); - /* "_pydevd_bundle/pydevd_cython.pyx":648 + /* "_pydevd_bundle/pydevd_cython.pyx":649 * * except: * if type(condition) != type(''): # <<<<<<<<<<<<<< * if hasattr(condition, 'encode'): * condition = condition.encode('utf-8') */ - __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_condition)), ((PyObject *)Py_TYPE(__pyx_kp_s_)), Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_condition)), ((PyObject *)Py_TYPE(__pyx_kp_s_)), Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__pyx_t_10) { + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":649 + /* "_pydevd_bundle/pydevd_cython.pyx":650 * except: * if type(condition) != type(''): * if hasattr(condition, 'encode'): # <<<<<<<<<<<<<< * condition = condition.encode('utf-8') * */ - __pyx_t_10 = PyObject_HasAttr(__pyx_v_condition, __pyx_n_s_encode); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = PyObject_HasAttr(__pyx_v_condition, __pyx_n_s_encode); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":650 + /* "_pydevd_bundle/pydevd_cython.pyx":651 * if type(condition) != type(''): * if hasattr(condition, 'encode'): * condition = condition.encode('utf-8') # <<<<<<<<<<<<<< * * msg = 'Error while evaluating expression: %s\n' % (condition,) */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_condition, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_condition, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF_SET(__pyx_v_condition, __pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":649 + /* "_pydevd_bundle/pydevd_cython.pyx":650 * except: * if type(condition) != type(''): * if hasattr(condition, 'encode'): # <<<<<<<<<<<<<< @@ -11279,7 +11286,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":648 + /* "_pydevd_bundle/pydevd_cython.pyx":649 * * except: * if type(condition) != type(''): # <<<<<<<<<<<<<< @@ -11288,37 +11295,37 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":652 + /* "_pydevd_bundle/pydevd_cython.pyx":653 * condition = condition.encode('utf-8') * * msg = 'Error while evaluating expression: %s\n' % (condition,) # <<<<<<<<<<<<<< * sys.stderr.write(msg) * traceback.print_exc() */ - __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_condition); __Pyx_GIVEREF(__pyx_v_condition); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_condition); - __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_Error_while_evaluating_expressio, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_Error_while_evaluating_expressio, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_msg = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":653 + /* "_pydevd_bundle/pydevd_cython.pyx":654 * * msg = 'Error while evaluating expression: %s\n' % (condition,) * sys.stderr.write(msg) # <<<<<<<<<<<<<< * traceback.print_exc() * if not main_debugger.suspend_on_breakpoint_exception: */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_stderr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_write); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_write); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -11332,32 +11339,32 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_6) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_msg); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_msg); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); } else { - __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_6); __pyx_t_6 = NULL; __Pyx_INCREF(__pyx_v_msg); __Pyx_GIVEREF(__pyx_v_msg); PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_v_msg); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_22, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_22, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":654 + /* "_pydevd_bundle/pydevd_cython.pyx":655 * msg = 'Error while evaluating expression: %s\n' % (condition,) * sys.stderr.write(msg) * traceback.print_exc() # <<<<<<<<<<<<<< * if not main_debugger.suspend_on_breakpoint_exception: * return self.trace_dispatch */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; @@ -11371,30 +11378,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_1) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_22); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 654; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_22); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":655 + /* "_pydevd_bundle/pydevd_cython.pyx":656 * sys.stderr.write(msg) * traceback.print_exc() * if not main_debugger.suspend_on_breakpoint_exception: # <<<<<<<<<<<<<< * return self.trace_dispatch * else: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_suspend_on_breakpoint_exception); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_suspend_on_breakpoint_exception); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 655; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_8 = ((!__pyx_t_9) != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":656 + /* "_pydevd_bundle/pydevd_cython.pyx":657 * traceback.print_exc() * if not main_debugger.suspend_on_breakpoint_exception: * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -11402,16 +11409,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * stop = True */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 656; __pyx_clineno = __LINE__; goto __pyx_L106_except_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L107_except_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - goto __pyx_L107_except_return; + goto __pyx_L108_except_return; - /* "_pydevd_bundle/pydevd_cython.pyx":655 + /* "_pydevd_bundle/pydevd_cython.pyx":656 * sys.stderr.write(msg) * traceback.print_exc() * if not main_debugger.suspend_on_breakpoint_exception: # <<<<<<<<<<<<<< @@ -11420,7 +11427,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":658 + /* "_pydevd_bundle/pydevd_cython.pyx":659 * return self.trace_dispatch * else: * stop = True # <<<<<<<<<<<<<< @@ -11431,7 +11438,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_stop, Py_True); - /* "_pydevd_bundle/pydevd_cython.pyx":659 + /* "_pydevd_bundle/pydevd_cython.pyx":660 * else: * stop = True * try: # <<<<<<<<<<<<<< @@ -11445,16 +11452,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":661 + /* "_pydevd_bundle/pydevd_cython.pyx":662 * try: * # add exception_type and stacktrace into thread additional info * etype, value, tb = sys.exc_info() # <<<<<<<<<<<<<< * try: * error = ''.join(traceback.format_exception_only(etype, value)) */ - __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __pyx_t_22 = NULL; @@ -11468,10 +11475,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_22) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_22); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_22); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } else { - __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11485,7 +11492,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -11501,36 +11508,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_22); __Pyx_INCREF(__pyx_t_6); #else - __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_22 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_22 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_6 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_6 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_6); #endif __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { Py_ssize_t index = -1; - __pyx_t_26 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + __pyx_t_26 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __Pyx_GOTREF(__pyx_t_26); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_7 = Py_TYPE(__pyx_t_26)->tp_iternext; - index = 0; __pyx_t_1 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_1)) goto __pyx_L126_unpacking_failed; + index = 0; __pyx_t_1 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_1)) goto __pyx_L127_unpacking_failed; __Pyx_GOTREF(__pyx_t_1); - index = 1; __pyx_t_22 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_22)) goto __pyx_L126_unpacking_failed; + index = 1; __pyx_t_22 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_22)) goto __pyx_L127_unpacking_failed; __Pyx_GOTREF(__pyx_t_22); - index = 2; __pyx_t_6 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_6)) goto __pyx_L126_unpacking_failed; + index = 2; __pyx_t_6 = __pyx_t_7(__pyx_t_26); if (unlikely(!__pyx_t_6)) goto __pyx_L127_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_26), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_26), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; - goto __pyx_L127_unpacking_done; - __pyx_L126_unpacking_failed:; + goto __pyx_L128_unpacking_done; + __pyx_L127_unpacking_failed:; __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 661; __pyx_clineno = __LINE__; goto __pyx_L118_error;} - __pyx_L127_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L119_error;} + __pyx_L128_unpacking_done:; } __pyx_v_etype = __pyx_t_1; __pyx_t_1 = 0; @@ -11539,7 +11546,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_tb = __pyx_t_6; __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":662 + /* "_pydevd_bundle/pydevd_cython.pyx":663 * # add exception_type and stacktrace into thread additional info * etype, value, tb = sys.exc_info() * try: # <<<<<<<<<<<<<< @@ -11548,16 +11555,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":663 + /* "_pydevd_bundle/pydevd_cython.pyx":664 * etype, value, tb = sys.exc_info() * try: * error = ''.join(traceback.format_exception_only(etype, value)) # <<<<<<<<<<<<<< * stack = traceback.extract_stack(f=tb.tb_frame.f_back) * */ - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_format_exception_only); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_format_exception_only); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -11572,7 +11579,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_1 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_1 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL; @@ -11583,60 +11590,60 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_11, __pyx_v_value); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_22 = __Pyx_PyString_Join(__pyx_kp_s_, __pyx_t_2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = __Pyx_PyString_Join(__pyx_kp_s_, __pyx_t_2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_error = ((PyObject*)__pyx_t_22); __pyx_t_22 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":664 + /* "_pydevd_bundle/pydevd_cython.pyx":665 * try: * error = ''.join(traceback.format_exception_only(etype, value)) * stack = traceback.extract_stack(f=tb.tb_frame.f_back) # <<<<<<<<<<<<<< * * # On self.set_suspend(thread, CMD_SET_BREAK) this info will be */ - __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_extract_stack); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_extract_stack); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_22 = PyDict_New(); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = PyDict_New(); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_tb, __pyx_n_s_tb_frame); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_tb, __pyx_n_s_tb_frame); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_f_back); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_f_back); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (PyDict_SetItem(__pyx_t_22, __pyx_n_s_f, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + if (PyDict_SetItem(__pyx_t_22, __pyx_n_s_f, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_22); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_22); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __pyx_v_stack = __pyx_t_6; __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":669 + /* "_pydevd_bundle/pydevd_cython.pyx":670 * # sent to the client. * info.conditional_breakpoint_exception = \ * ('Condition:\n' + condition + '\n\nError:\n' + error, stack) # <<<<<<<<<<<<<< * finally: * etype, value, tb = None, None, None */ - __pyx_t_6 = PyNumber_Add(__pyx_kp_s_Condition, __pyx_v_condition); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 669; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_6 = PyNumber_Add(__pyx_kp_s_Condition, __pyx_v_condition); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_22 = PyNumber_Add(__pyx_t_6, __pyx_kp_s_Error); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 669; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = PyNumber_Add(__pyx_t_6, __pyx_kp_s_Error); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = PyNumber_Add(__pyx_t_22, __pyx_v_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 669; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_6 = PyNumber_Add(__pyx_t_22, __pyx_v_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_22 = PyTuple_New(2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 669; __pyx_clineno = __LINE__; goto __pyx_L131_error;} + __pyx_t_22 = PyTuple_New(2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L132_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_6); @@ -11645,7 +11652,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di PyTuple_SET_ITEM(__pyx_t_22, 1, __pyx_v_stack); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":668 + /* "_pydevd_bundle/pydevd_cython.pyx":669 * # On self.set_suspend(thread, CMD_SET_BREAK) this info will be * # sent to the client. * info.conditional_breakpoint_exception = \ # <<<<<<<<<<<<<< @@ -11659,7 +11666,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_22 = 0; } - /* "_pydevd_bundle/pydevd_cython.pyx":671 + /* "_pydevd_bundle/pydevd_cython.pyx":672 * ('Condition:\n' + condition + '\n\nError:\n' + error, stack) * finally: * etype, value, tb = None, None, None # <<<<<<<<<<<<<< @@ -11680,10 +11687,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_tb, __pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L132; + goto __pyx_L133; } /*exception exit:*/{ - __pyx_L131_error:; + __pyx_L132_error:; __pyx_t_29 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0; __pyx_t_33 = 0; __pyx_t_34 = 0; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11726,12 +11733,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_ErrRestore(__pyx_t_29, __pyx_t_30, __pyx_t_31); __pyx_t_29 = 0; __pyx_t_30 = 0; __pyx_t_31 = 0; __pyx_t_32 = 0; __pyx_t_33 = 0; __pyx_t_34 = 0; __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_27; __pyx_filename = __pyx_t_28; - goto __pyx_L118_error; + goto __pyx_L119_error; } - __pyx_L132:; + __pyx_L133:; } - /* "_pydevd_bundle/pydevd_cython.pyx":659 + /* "_pydevd_bundle/pydevd_cython.pyx":660 * else: * stop = True * try: # <<<<<<<<<<<<<< @@ -11742,8 +11749,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; - goto __pyx_L125_try_end; - __pyx_L118_error:; + goto __pyx_L126_try_end; + __pyx_L119_error:; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -11751,7 +11758,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":672 + /* "_pydevd_bundle/pydevd_cython.pyx":673 * finally: * etype, value, tb = None, None, None * except: # <<<<<<<<<<<<<< @@ -11760,21 +11767,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_22, &__pyx_t_6, &__pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; __pyx_clineno = __LINE__; goto __pyx_L120_except_error;} + if (__Pyx_GetException(&__pyx_t_22, &__pyx_t_6, &__pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L121_except_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_2); - /* "_pydevd_bundle/pydevd_cython.pyx":673 + /* "_pydevd_bundle/pydevd_cython.pyx":674 * etype, value, tb = None, None, None * except: * traceback.print_exc() # <<<<<<<<<<<<<< * * if breakpoint.expression is not None: */ - __pyx_t_26 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L120_except_error;} + __pyx_t_26 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; __pyx_clineno = __LINE__; goto __pyx_L121_except_error;} __Pyx_GOTREF(__pyx_t_26); - __pyx_t_35 = __Pyx_PyObject_GetAttrStr(__pyx_t_26, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_35)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L120_except_error;} + __pyx_t_35 = __Pyx_PyObject_GetAttrStr(__pyx_t_26, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_35)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; __pyx_clineno = __LINE__; goto __pyx_L121_except_error;} __Pyx_GOTREF(__pyx_t_35); __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; __pyx_t_26 = NULL; @@ -11788,10 +11795,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_26) { - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_35, __pyx_t_26); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L120_except_error;} + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_35, __pyx_t_26); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; __pyx_clineno = __LINE__; goto __pyx_L121_except_error;} __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0; } else { - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_35); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 673; __pyx_clineno = __LINE__; goto __pyx_L120_except_error;} + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_35); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 674; __pyx_clineno = __LINE__; goto __pyx_L121_except_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_35); __pyx_t_35 = 0; @@ -11799,11 +11806,11 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L119_exception_handled; + goto __pyx_L120_exception_handled; } - __pyx_L120_except_error:; + __pyx_L121_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":659 + /* "_pydevd_bundle/pydevd_cython.pyx":660 * else: * stop = True * try: # <<<<<<<<<<<<<< @@ -11814,23 +11821,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); - goto __pyx_L106_except_error; - __pyx_L119_exception_handled:; + goto __pyx_L107_except_error; + __pyx_L120_exception_handled:; __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); - __pyx_L125_try_end:; + __pyx_L126_try_end:; } } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - goto __pyx_L105_exception_handled; + goto __pyx_L106_exception_handled; } - __pyx_L106_except_error:; + __pyx_L107_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":642 + /* "_pydevd_bundle/pydevd_cython.pyx":643 * condition = breakpoint.condition * if condition is not None: * try: # <<<<<<<<<<<<<< @@ -11841,28 +11848,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); - goto __pyx_L74_error; - __pyx_L108_try_return:; + goto __pyx_L75_error; + __pyx_L109_try_return:; __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); - goto __pyx_L78_try_return; - __pyx_L107_except_return:; + goto __pyx_L79_try_return; + __pyx_L108_except_return:; __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); - goto __pyx_L78_try_return; - __pyx_L105_exception_handled:; + goto __pyx_L79_try_return; + __pyx_L106_exception_handled:; __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); - __pyx_L111_try_end:; + __pyx_L112_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":641 + /* "_pydevd_bundle/pydevd_cython.pyx":642 * if stop or exist_result: * condition = breakpoint.condition * if condition is not None: # <<<<<<<<<<<<<< @@ -11871,21 +11878,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":675 + /* "_pydevd_bundle/pydevd_cython.pyx":676 * traceback.print_exc() * * if breakpoint.expression is not None: # <<<<<<<<<<<<<< * try: * try: */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_expression); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 675; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_expression); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_10 = (__pyx_t_4 != Py_None); + __pyx_t_8 = (__pyx_t_4 != Py_None); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":676 + /* "_pydevd_bundle/pydevd_cython.pyx":677 * * if breakpoint.expression is not None: * try: # <<<<<<<<<<<<<< @@ -11894,7 +11901,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":677 + /* "_pydevd_bundle/pydevd_cython.pyx":678 * if breakpoint.expression is not None: * try: * try: # <<<<<<<<<<<<<< @@ -11908,22 +11915,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_19); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":678 + /* "_pydevd_bundle/pydevd_cython.pyx":679 * try: * try: * val = eval(breakpoint.expression, new_frame.f_globals, new_frame.f_locals) # <<<<<<<<<<<<<< * except: * val = sys.exc_info()[1] */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_expression); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_breakpoint, __pyx_n_s_expression); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} __Pyx_GOTREF(__pyx_t_4); - if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_globals); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} + if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_globals); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} __Pyx_GOTREF(__pyx_t_3); - if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} + if (unlikely(!__pyx_v_new_frame)) { __Pyx_RaiseUnboundLocalError("new_frame"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_new_frame, __pyx_n_s_f_locals); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); @@ -11934,13 +11941,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_eval, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 678; __pyx_clineno = __LINE__; goto __pyx_L145_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_eval, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L146_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":677 + /* "_pydevd_bundle/pydevd_cython.pyx":678 * if breakpoint.expression is not None: * try: * try: # <<<<<<<<<<<<<< @@ -11951,8 +11958,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; - goto __pyx_L152_try_end; - __pyx_L145_error:; + goto __pyx_L153_try_end; + __pyx_L146_error:; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_35); __pyx_t_35 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -11964,7 +11971,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":679 + /* "_pydevd_bundle/pydevd_cython.pyx":680 * try: * val = eval(breakpoint.expression, new_frame.f_globals, new_frame.f_locals) * except: # <<<<<<<<<<<<<< @@ -11973,21 +11980,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_2, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 679; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;} + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_2, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_3); - /* "_pydevd_bundle/pydevd_cython.pyx":680 + /* "_pydevd_bundle/pydevd_cython.pyx":681 * val = eval(breakpoint.expression, new_frame.f_globals, new_frame.f_locals) * except: * val = sys.exc_info()[1] # <<<<<<<<<<<<<< * finally: * if val is not None: */ - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; @@ -12001,14 +12008,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_6) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;} + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { - __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_22); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;} + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_22); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 680; __pyx_clineno = __LINE__; goto __pyx_L147_except_error;}; + __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_4, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 681; __pyx_clineno = __LINE__; goto __pyx_L148_except_error;}; __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_22); @@ -12016,11 +12023,11 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L146_exception_handled; + goto __pyx_L147_exception_handled; } - __pyx_L147_except_error:; + __pyx_L148_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":677 + /* "_pydevd_bundle/pydevd_cython.pyx":678 * if breakpoint.expression is not None: * try: * try: # <<<<<<<<<<<<<< @@ -12031,17 +12038,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_20, __pyx_t_19); - goto __pyx_L143_error; - __pyx_L146_exception_handled:; + goto __pyx_L144_error; + __pyx_L147_exception_handled:; __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_20, __pyx_t_19); - __pyx_L152_try_end:; + __pyx_L153_try_end:; } } - /* "_pydevd_bundle/pydevd_cython.pyx":682 + /* "_pydevd_bundle/pydevd_cython.pyx":683 * val = sys.exc_info()[1] * finally: * if val is not None: # <<<<<<<<<<<<<< @@ -12051,32 +12058,32 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di /*finally:*/ { /*normal exit:*/{ __pyx_t_9 = (__pyx_v_val != Py_None); - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":683 + /* "_pydevd_bundle/pydevd_cython.pyx":684 * finally: * if val is not None: * info.pydev_message = str(val) # <<<<<<<<<<<<<< * * if not main_debugger.first_breakpoint_reached: */ - __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_val); __Pyx_GIVEREF(__pyx_v_val); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_val); - __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_v_info->pydev_message); __Pyx_DECREF(__pyx_v_info->pydev_message); __pyx_v_info->pydev_message = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":682 + /* "_pydevd_bundle/pydevd_cython.pyx":683 * val = sys.exc_info()[1] * finally: * if val is not None: # <<<<<<<<<<<<<< @@ -12084,10 +12091,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * */ } - goto __pyx_L144; + goto __pyx_L145; } /*exception exit:*/{ - __pyx_L143_error:; + __pyx_L144_error:; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_25 = 0; __pyx_t_24 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_35); __pyx_t_35 = 0; @@ -12109,35 +12116,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_23); __pyx_t_27 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_36 = __pyx_filename; { - if (unlikely(!__pyx_v_val)) { __Pyx_RaiseUnboundLocalError("val"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 682; __pyx_clineno = __LINE__; goto __pyx_L159_error;} } - __pyx_t_10 = (__pyx_v_val != Py_None); - __pyx_t_9 = (__pyx_t_10 != 0); + if (unlikely(!__pyx_v_val)) { __Pyx_RaiseUnboundLocalError("val"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L160_error;} } + __pyx_t_8 = (__pyx_v_val != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":683 + /* "_pydevd_bundle/pydevd_cython.pyx":684 * finally: * if val is not None: * info.pydev_message = str(val) # <<<<<<<<<<<<<< * * if not main_debugger.first_breakpoint_reached: */ - if (unlikely(!__pyx_v_val)) { __Pyx_RaiseUnboundLocalError("val"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L159_error;} } - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L159_error;} + if (unlikely(!__pyx_v_val)) { __Pyx_RaiseUnboundLocalError("val"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L160_error;} } + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L160_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_v_val); __Pyx_GIVEREF(__pyx_v_val); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_val); - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L159_error;} + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L160_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L159_error;} + if (!(likely(PyString_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L160_error;} __Pyx_GIVEREF(__pyx_t_3); __Pyx_GOTREF(__pyx_v_info->pydev_message); __Pyx_DECREF(__pyx_v_info->pydev_message); __pyx_v_info->pydev_message = ((PyObject*)__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":682 + /* "_pydevd_bundle/pydevd_cython.pyx":683 * val = sys.exc_info()[1] * finally: * if val is not None: # <<<<<<<<<<<<<< @@ -12158,8 +12165,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_ErrRestore(__pyx_t_19, __pyx_t_20, __pyx_t_21); __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_25 = 0; __pyx_t_24 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_27; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_36; - goto __pyx_L74_error; - __pyx_L159_error:; + goto __pyx_L75_error; + __pyx_L160_error:; if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_24); @@ -12170,12 +12177,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __pyx_t_25 = 0; __pyx_t_24 = 0; __pyx_t_23 = 0; - goto __pyx_L74_error; + goto __pyx_L75_error; } - __pyx_L144:; + __pyx_L145:; } - /* "_pydevd_bundle/pydevd_cython.pyx":675 + /* "_pydevd_bundle/pydevd_cython.pyx":676 * traceback.print_exc() * * if breakpoint.expression is not None: # <<<<<<<<<<<<<< @@ -12184,73 +12191,73 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":685 + /* "_pydevd_bundle/pydevd_cython.pyx":686 * info.pydev_message = str(val) * * if not main_debugger.first_breakpoint_reached: # <<<<<<<<<<<<<< * if event == 'call': * if hasattr(frame, 'f_back'): */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_first_breakpoint_reached); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_first_breakpoint_reached); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_8 = ((!__pyx_t_9) != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":686 + /* "_pydevd_bundle/pydevd_cython.pyx":687 * * if not main_debugger.first_breakpoint_reached: * if event == 'call': # <<<<<<<<<<<<<< * if hasattr(frame, 'f_back'): * back = frame.f_back */ - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_call, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":687 + /* "_pydevd_bundle/pydevd_cython.pyx":688 * if not main_debugger.first_breakpoint_reached: * if event == 'call': * if hasattr(frame, 'f_back'): # <<<<<<<<<<<<<< * back = frame.f_back * if back is not None: */ - __pyx_t_9 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_9 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":688 + /* "_pydevd_bundle/pydevd_cython.pyx":689 * if event == 'call': * if hasattr(frame, 'f_back'): * back = frame.f_back # <<<<<<<<<<<<<< * if back is not None: * # When we start debug session, we call execfile in pydevd run function. It produces an additional */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_v_back = __pyx_t_3; __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":689 + /* "_pydevd_bundle/pydevd_cython.pyx":690 * if hasattr(frame, 'f_back'): * back = frame.f_back * if back is not None: # <<<<<<<<<<<<<< * # When we start debug session, we call execfile in pydevd run function. It produces an additional * # 'call' event for tracing and we stop on the first line of code twice. */ - __pyx_t_10 = (__pyx_v_back != Py_None); - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = (__pyx_v_back != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":692 + /* "_pydevd_bundle/pydevd_cython.pyx":693 * # When we start debug session, we call execfile in pydevd run function. It produces an additional * # 'call' event for tracing and we stop on the first line of code twice. * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) # <<<<<<<<<<<<<< * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ * (base == DEBUG_START_PY3K[0] and back.f_code.co_name == DEBUG_START_PY3K[1]): */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -12263,16 +12270,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_5) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_back); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_back); __Pyx_GIVEREF(__pyx_v_back); PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_v_back); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_22, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_22, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } @@ -12287,7 +12294,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -12303,36 +12310,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_22); __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_22 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_22 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); #endif __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { Py_ssize_t index = -1; - __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; - index = 0; __pyx_t_2 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L165_unpacking_failed; + index = 0; __pyx_t_2 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L166_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - index = 1; __pyx_t_22 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_22)) goto __pyx_L165_unpacking_failed; + index = 1; __pyx_t_22 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_22)) goto __pyx_L166_unpacking_failed; __Pyx_GOTREF(__pyx_t_22); - index = 2; __pyx_t_5 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L165_unpacking_failed; + index = 2; __pyx_t_5 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_5)) goto __pyx_L166_unpacking_failed; __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - goto __pyx_L166_unpacking_done; - __pyx_L165_unpacking_failed:; + goto __pyx_L167_unpacking_done; + __pyx_L166_unpacking_failed:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 692; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - __pyx_L166_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + __pyx_L167_unpacking_done:; } __pyx_v__ = __pyx_t_2; __pyx_t_2 = 0; @@ -12341,88 +12348,88 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_base = __pyx_t_5; __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":693 + /* "_pydevd_bundle/pydevd_cython.pyx":694 * # 'call' event for tracing and we stop on the first line of code twice. * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ # <<<<<<<<<<<<<< * (base == DEBUG_START_PY3K[0] and back.f_code.co_name == DEBUG_START_PY3K[1]): * stop = False */ - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;}; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;}; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyObject_RichCompare(__pyx_v_base, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_base, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_10) { - goto __pyx_L169_next_or; + if (!__pyx_t_8) { + goto __pyx_L170_next_or; } else { } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_name); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_name); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;}; + __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;}; __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 693; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_10) { + if (!__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L168_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L169_bool_binop_done; } - __pyx_L169_next_or:; + __pyx_L170_next_or:; - /* "_pydevd_bundle/pydevd_cython.pyx":694 + /* "_pydevd_bundle/pydevd_cython.pyx":695 * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ * (base == DEBUG_START_PY3K[0] and back.f_code.co_name == DEBUG_START_PY3K[1]): # <<<<<<<<<<<<<< * stop = False * main_debugger.first_breakpoint_reached = True */ - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START_PY3K); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START_PY3K); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;}; + __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;}; __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyObject_RichCompare(__pyx_v_base, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_v_base, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_10) { + if (__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L168_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L169_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_name); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_name); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START_PY3K); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START_PY3K); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;}; + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;}; __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = PyObject_RichCompare(__pyx_t_22, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_t_22, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 695; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __pyx_t_10; - __pyx_L168_bool_binop_done:; + __pyx_t_9 = __pyx_t_8; + __pyx_L169_bool_binop_done:; - /* "_pydevd_bundle/pydevd_cython.pyx":693 + /* "_pydevd_bundle/pydevd_cython.pyx":694 * # 'call' event for tracing and we stop on the first line of code twice. * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ # <<<<<<<<<<<<<< @@ -12431,7 +12438,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":695 + /* "_pydevd_bundle/pydevd_cython.pyx":696 * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ * (base == DEBUG_START_PY3K[0] and back.f_code.co_name == DEBUG_START_PY3K[1]): * stop = False # <<<<<<<<<<<<<< @@ -12441,16 +12448,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":696 + /* "_pydevd_bundle/pydevd_cython.pyx":697 * (base == DEBUG_START_PY3K[0] and back.f_code.co_name == DEBUG_START_PY3K[1]): * stop = False * main_debugger.first_breakpoint_reached = True # <<<<<<<<<<<<<< * else: * # if the frame is traced after breakpoint stop, */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_first_breakpoint_reached, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_main_debugger, __pyx_n_s_first_breakpoint_reached, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L75_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":693 + /* "_pydevd_bundle/pydevd_cython.pyx":694 * # 'call' event for tracing and we stop on the first line of code twice. * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if (base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]) or \ # <<<<<<<<<<<<<< @@ -12459,7 +12466,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":689 + /* "_pydevd_bundle/pydevd_cython.pyx":690 * if hasattr(frame, 'f_back'): * back = frame.f_back * if back is not None: # <<<<<<<<<<<<<< @@ -12468,7 +12475,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":687 + /* "_pydevd_bundle/pydevd_cython.pyx":688 * if not main_debugger.first_breakpoint_reached: * if event == 'call': * if hasattr(frame, 'f_back'): # <<<<<<<<<<<<<< @@ -12477,7 +12484,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":686 + /* "_pydevd_bundle/pydevd_cython.pyx":687 * * if not main_debugger.first_breakpoint_reached: * if event == 'call': # <<<<<<<<<<<<<< @@ -12486,7 +12493,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":685 + /* "_pydevd_bundle/pydevd_cython.pyx":686 * info.pydev_message = str(val) * * if not main_debugger.first_breakpoint_reached: # <<<<<<<<<<<<<< @@ -12495,7 +12502,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":639 + /* "_pydevd_bundle/pydevd_cython.pyx":640 * #ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint * # lets do the conditional stuff here * if stop or exist_result: # <<<<<<<<<<<<<< @@ -12504,17 +12511,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":636 + /* "_pydevd_bundle/pydevd_cython.pyx":637 * (flag, breakpoint, new_frame, bp_type) = result * * if breakpoint: # <<<<<<<<<<<<<< * #ok, hit breakpoint, now, we have to discover if it is a conditional breakpoint * # lets do the conditional stuff here */ - goto __pyx_L99; + goto __pyx_L100; } - /* "_pydevd_bundle/pydevd_cython.pyx":700 + /* "_pydevd_bundle/pydevd_cython.pyx":701 * # if the frame is traced after breakpoint stop, * # but the file should be ignored while stepping because of filters * if step_cmd != -1: # <<<<<<<<<<<<<< @@ -12525,23 +12532,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_9 = ((__pyx_v_step_cmd != -1L) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":701 + /* "_pydevd_bundle/pydevd_cython.pyx":702 * # but the file should be ignored while stepping because of filters * if step_cmd != -1: * if main_debugger.is_filter_enabled and main_debugger.is_ignored_by_filters(filename): # <<<<<<<<<<<<<< * # ignore files matching stepping filters * return self.trace_dispatch */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_filter_enabled); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_filter_enabled); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_10) { + if (__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L174_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L175_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_ignored_by_filters); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_ignored_by_filters); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_22 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { @@ -12554,27 +12561,27 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_22) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_22); __pyx_t_22 = NULL; __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_filename); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 701; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __pyx_t_10; - __pyx_L174_bool_binop_done:; + __pyx_t_9 = __pyx_t_8; + __pyx_L175_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":703 + /* "_pydevd_bundle/pydevd_cython.pyx":704 * if main_debugger.is_filter_enabled and main_debugger.is_ignored_by_filters(filename): * # ignore files matching stepping filters * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -12582,13 +12589,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * # ignore library files while stepping */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 703; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; - goto __pyx_L78_try_return; + goto __pyx_L79_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":701 + /* "_pydevd_bundle/pydevd_cython.pyx":702 * # but the file should be ignored while stepping because of filters * if step_cmd != -1: * if main_debugger.is_filter_enabled and main_debugger.is_ignored_by_filters(filename): # <<<<<<<<<<<<<< @@ -12597,23 +12604,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":704 + /* "_pydevd_bundle/pydevd_cython.pyx":705 * # ignore files matching stepping filters * return self.trace_dispatch * if main_debugger.is_filter_libraries and main_debugger.not_in_scope(filename): # <<<<<<<<<<<<<< * # ignore library files while stepping * return self.trace_dispatch */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_filter_libraries); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_is_filter_libraries); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (__pyx_t_10) { + if (__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L177_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L178_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { @@ -12626,27 +12633,27 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_2) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_filename); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_2); __pyx_t_2 = NULL; __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_v_filename); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_22, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_22, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 704; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 705; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __pyx_t_10; - __pyx_L177_bool_binop_done:; + __pyx_t_9 = __pyx_t_8; + __pyx_L178_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":706 + /* "_pydevd_bundle/pydevd_cython.pyx":707 * if main_debugger.is_filter_libraries and main_debugger.not_in_scope(filename): * # ignore library files while stepping * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -12654,13 +12661,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if main_debugger.show_return_values or main_debugger.remove_return_values_flag: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 706; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_r = __pyx_t_3; __pyx_t_3 = 0; - goto __pyx_L78_try_return; + goto __pyx_L79_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":704 + /* "_pydevd_bundle/pydevd_cython.pyx":705 * # ignore files matching stepping filters * return self.trace_dispatch * if main_debugger.is_filter_libraries and main_debugger.not_in_scope(filename): # <<<<<<<<<<<<<< @@ -12669,7 +12676,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":700 + /* "_pydevd_bundle/pydevd_cython.pyx":701 * # if the frame is traced after breakpoint stop, * # but the file should be ignored while stepping because of filters * if step_cmd != -1: # <<<<<<<<<<<<<< @@ -12678,40 +12685,40 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } } - __pyx_L99:; + __pyx_L100:; - /* "_pydevd_bundle/pydevd_cython.pyx":708 + /* "_pydevd_bundle/pydevd_cython.pyx":709 * return self.trace_dispatch * * if main_debugger.show_return_values or main_debugger.remove_return_values_flag: # <<<<<<<<<<<<<< * self.manage_return_values(main_debugger, frame, event, arg) * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_show_return_values); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (!__pyx_t_10) { + if (!__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L180_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L181_bool_binop_done; } - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_remove_return_values_flag); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __pyx_t_10; - __pyx_L180_bool_binop_done:; + __pyx_t_9 = __pyx_t_8; + __pyx_L181_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":709 + /* "_pydevd_bundle/pydevd_cython.pyx":710 * * if main_debugger.show_return_values or main_debugger.remove_return_values_flag: * self.manage_return_values(main_debugger, frame, event, arg) # <<<<<<<<<<<<<< * * if stop: */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_manage_return_values); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_manage_return_values); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_22 = NULL; __pyx_t_11 = 0; @@ -12725,7 +12732,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_2 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_22) { __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_22); __pyx_t_22 = NULL; @@ -12742,13 +12749,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_2, 3+__pyx_t_11, __pyx_v_arg); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 709; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":708 + /* "_pydevd_bundle/pydevd_cython.pyx":709 * return self.trace_dispatch * * if main_debugger.show_return_values or main_debugger.remove_return_values_flag: # <<<<<<<<<<<<<< @@ -12757,26 +12764,26 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":711 + /* "_pydevd_bundle/pydevd_cython.pyx":712 * self.manage_return_values(main_debugger, frame, event, arg) * * if stop: # <<<<<<<<<<<<<< * self.set_suspend(thread, CMD_SET_BREAK) * elif flag and plugin_manager is not None: */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __pyx_L75_error;} if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":712 + /* "_pydevd_bundle/pydevd_cython.pyx":713 * * if stop: * self.set_suspend(thread, CMD_SET_BREAK) # <<<<<<<<<<<<<< * elif flag and plugin_manager is not None: * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SET_BREAK); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SET_BREAK); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_22 = NULL; __pyx_t_11 = 0; @@ -12790,7 +12797,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_22) { __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_22); __pyx_t_22 = NULL; @@ -12801,49 +12808,49 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 712; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":711 + /* "_pydevd_bundle/pydevd_cython.pyx":712 * self.manage_return_values(main_debugger, frame, event, arg) * * if stop: # <<<<<<<<<<<<<< * self.set_suspend(thread, CMD_SET_BREAK) * elif flag and plugin_manager is not None: */ - goto __pyx_L182; + goto __pyx_L183; } - /* "_pydevd_bundle/pydevd_cython.pyx":713 + /* "_pydevd_bundle/pydevd_cython.pyx":714 * if stop: * self.set_suspend(thread, CMD_SET_BREAK) * elif flag and plugin_manager is not None: # <<<<<<<<<<<<<< * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) * if result: */ - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L74_error;} - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L75_error;} + if (__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L183_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L184_bool_binop_done; } - __pyx_t_10 = (__pyx_v_plugin_manager != Py_None); - __pyx_t_8 = (__pyx_t_10 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L183_bool_binop_done:; + __pyx_t_8 = (__pyx_v_plugin_manager != Py_None); + __pyx_t_10 = (__pyx_t_8 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L184_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":714 + /* "_pydevd_bundle/pydevd_cython.pyx":715 * self.set_suspend(thread, CMD_SET_BREAK) * elif flag and plugin_manager is not None: * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) # <<<<<<<<<<<<<< * if result: * frame = result */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -12857,7 +12864,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_2 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -12874,24 +12881,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_bp_type); __Pyx_GIVEREF(__pyx_v_bp_type); PyTuple_SET_ITEM(__pyx_t_2, 3+__pyx_t_11, __pyx_v_bp_type); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_result, __pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":715 + /* "_pydevd_bundle/pydevd_cython.pyx":716 * elif flag and plugin_manager is not None: * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) * if result: # <<<<<<<<<<<<<< * frame = result * */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 715; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 716; __pyx_clineno = __LINE__; goto __pyx_L75_error;} if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":716 + /* "_pydevd_bundle/pydevd_cython.pyx":717 * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) * if result: * frame = result # <<<<<<<<<<<<<< @@ -12901,7 +12908,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_result); __Pyx_DECREF_SET(__pyx_v_frame, __pyx_v_result); - /* "_pydevd_bundle/pydevd_cython.pyx":715 + /* "_pydevd_bundle/pydevd_cython.pyx":716 * elif flag and plugin_manager is not None: * result = plugin_manager.suspend(main_debugger, thread, frame, bp_type) * if result: # <<<<<<<<<<<<<< @@ -12910,7 +12917,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":713 + /* "_pydevd_bundle/pydevd_cython.pyx":714 * if stop: * self.set_suspend(thread, CMD_SET_BREAK) * elif flag and plugin_manager is not None: # <<<<<<<<<<<<<< @@ -12918,34 +12925,34 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if result: */ } - __pyx_L182:; + __pyx_L183:; - /* "_pydevd_bundle/pydevd_cython.pyx":719 + /* "_pydevd_bundle/pydevd_cython.pyx":720 * * # if thread has a suspend flag, we suspend with a busy wait * if info.pydev_state == STATE_SUSPEND: # <<<<<<<<<<<<<< * self.do_wait_suspend(thread, frame, event, arg) * return self.trace_dispatch */ - __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_info->pydev_state); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_SUSPEND); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_SUSPEND); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 719; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":720 + /* "_pydevd_bundle/pydevd_cython.pyx":721 * # if thread has a suspend flag, we suspend with a busy wait * if info.pydev_state == STATE_SUSPEND: * self.do_wait_suspend(thread, frame, event, arg) # <<<<<<<<<<<<<< * return self.trace_dispatch * */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = NULL; __pyx_t_11 = 0; @@ -12959,7 +12966,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_4 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_4 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -12976,13 +12983,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_11, __pyx_v_arg); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 720; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":721 + /* "_pydevd_bundle/pydevd_cython.pyx":722 * if info.pydev_state == STATE_SUSPEND: * self.do_wait_suspend(thread, frame, event, arg) * return self.trace_dispatch # <<<<<<<<<<<<<< @@ -12990,13 +12997,13 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * except: */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L74_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 722; __pyx_clineno = __LINE__; goto __pyx_L75_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_r = __pyx_t_2; __pyx_t_2 = 0; - goto __pyx_L78_try_return; + goto __pyx_L79_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":719 + /* "_pydevd_bundle/pydevd_cython.pyx":720 * * # if thread has a suspend flag, we suspend with a busy wait * if info.pydev_state == STATE_SUSPEND: # <<<<<<<<<<<<<< @@ -13005,7 +13012,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":612 + /* "_pydevd_bundle/pydevd_cython.pyx":613 * #print 'NOT skipped', frame.f_lineno, frame.f_code.co_name, event * * try: # <<<<<<<<<<<<<< @@ -13016,8 +13023,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; - goto __pyx_L81_try_end; - __pyx_L74_error:; + goto __pyx_L82_try_end; + __pyx_L75_error:; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_35); __pyx_t_35 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -13029,7 +13036,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":723 + /* "_pydevd_bundle/pydevd_cython.pyx":724 * return self.trace_dispatch * * except: # <<<<<<<<<<<<<< @@ -13038,21 +13045,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 723; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_4); - /* "_pydevd_bundle/pydevd_cython.pyx":724 + /* "_pydevd_bundle/pydevd_cython.pyx":725 * * except: * traceback.print_exc() # <<<<<<<<<<<<<< * raise * */ - __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} __Pyx_GOTREF(__pyx_t_22); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __pyx_t_22 = NULL; @@ -13066,16 +13073,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_22) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_22); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_22); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } else { - __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 724; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} } __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":725 + /* "_pydevd_bundle/pydevd_cython.pyx":726 * except: * traceback.print_exc() * raise # <<<<<<<<<<<<<< @@ -13087,11 +13094,11 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ErrRestore(__pyx_t_2, __pyx_t_5, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 725; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 726; __pyx_clineno = __LINE__; goto __pyx_L77_except_error;} } - __pyx_L76_except_error:; + __pyx_L77_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":612 + /* "_pydevd_bundle/pydevd_cython.pyx":613 * #print 'NOT skipped', frame.f_lineno, frame.f_code.co_name, event * * try: # <<<<<<<<<<<<<< @@ -13103,16 +13110,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); goto __pyx_L6_error; - __pyx_L78_try_return:; + __pyx_L79_try_return:; __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); goto __pyx_L5_return; - __pyx_L81_try_end:; + __pyx_L82_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":728 + /* "_pydevd_bundle/pydevd_cython.pyx":729 * * #step handling. We stop when we hit the right frame * try: # <<<<<<<<<<<<<< @@ -13126,7 +13133,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_15); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":729 + /* "_pydevd_bundle/pydevd_cython.pyx":730 * #step handling. We stop when we hit the right frame * try: * should_skip = 0 # <<<<<<<<<<<<<< @@ -13136,49 +13143,49 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_int_0); __pyx_v_should_skip = __pyx_int_0; - /* "_pydevd_bundle/pydevd_cython.pyx":730 + /* "_pydevd_bundle/pydevd_cython.pyx":731 * try: * should_skip = 0 * if pydevd_dont_trace.should_trace_hook is not None: # <<<<<<<<<<<<<< * if self.should_skip == -1: * # I.e.: cache the result on self.should_skip (no need to evaluate the same frame multiple times). */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 730; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_9 = (__pyx_t_5 != Py_None); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":731 + /* "_pydevd_bundle/pydevd_cython.pyx":732 * should_skip = 0 * if pydevd_dont_trace.should_trace_hook is not None: * if self.should_skip == -1: # <<<<<<<<<<<<<< * # I.e.: cache the result on self.should_skip (no need to evaluate the same frame multiple times). * # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_skip); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_skip); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 732; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_5, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_5, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 732; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 731; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 732; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":735 + /* "_pydevd_bundle/pydevd_cython.pyx":736 * # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code * # Which will be handled by this frame is read-only, so, we can cache it safely. * if not pydevd_dont_trace.should_trace_hook(frame, filename): # <<<<<<<<<<<<<< * # -1, 0, 1 to be Cython-friendly * should_skip = self.should_skip = 1 */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -13193,7 +13200,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_3 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -13204,16 +13211,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_filename); __Pyx_GIVEREF(__pyx_v_filename); PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_11, __pyx_v_filename); - __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 735; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 736; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); + __pyx_t_9 = ((!__pyx_t_10) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":737 + /* "_pydevd_bundle/pydevd_cython.pyx":738 * if not pydevd_dont_trace.should_trace_hook(frame, filename): * # -1, 0, 1 to be Cython-friendly * should_skip = self.should_skip = 1 # <<<<<<<<<<<<<< @@ -13222,19 +13229,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_int_1); __Pyx_DECREF_SET(__pyx_v_should_skip, __pyx_int_1); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_should_skip, __pyx_int_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 737; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_should_skip, __pyx_int_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 738; __pyx_clineno = __LINE__; goto __pyx_L190_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":735 + /* "_pydevd_bundle/pydevd_cython.pyx":736 * # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code * # Which will be handled by this frame is read-only, so, we can cache it safely. * if not pydevd_dont_trace.should_trace_hook(frame, filename): # <<<<<<<<<<<<<< * # -1, 0, 1 to be Cython-friendly * should_skip = self.should_skip = 1 */ - goto __pyx_L199; + goto __pyx_L200; } - /* "_pydevd_bundle/pydevd_cython.pyx":739 + /* "_pydevd_bundle/pydevd_cython.pyx":740 * should_skip = self.should_skip = 1 * else: * should_skip = self.should_skip = 0 # <<<<<<<<<<<<<< @@ -13244,21 +13251,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di /*else*/ { __Pyx_INCREF(__pyx_int_0); __Pyx_DECREF_SET(__pyx_v_should_skip, __pyx_int_0); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_should_skip, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 739; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_should_skip, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 740; __pyx_clineno = __LINE__; goto __pyx_L190_error;} } - __pyx_L199:; + __pyx_L200:; - /* "_pydevd_bundle/pydevd_cython.pyx":731 + /* "_pydevd_bundle/pydevd_cython.pyx":732 * should_skip = 0 * if pydevd_dont_trace.should_trace_hook is not None: * if self.should_skip == -1: # <<<<<<<<<<<<<< * # I.e.: cache the result on self.should_skip (no need to evaluate the same frame multiple times). * # Note that on a code reload, we won't re-evaluate this because in practice, the frame.f_code */ - goto __pyx_L198; + goto __pyx_L199; } - /* "_pydevd_bundle/pydevd_cython.pyx":741 + /* "_pydevd_bundle/pydevd_cython.pyx":742 * should_skip = self.should_skip = 0 * else: * should_skip = self.should_skip # <<<<<<<<<<<<<< @@ -13266,14 +13273,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * plugin_stop = False */ /*else*/ { - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_skip); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 741; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_should_skip); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 742; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF_SET(__pyx_v_should_skip, __pyx_t_4); __pyx_t_4 = 0; } - __pyx_L198:; + __pyx_L199:; - /* "_pydevd_bundle/pydevd_cython.pyx":730 + /* "_pydevd_bundle/pydevd_cython.pyx":731 * try: * should_skip = 0 * if pydevd_dont_trace.should_trace_hook is not None: # <<<<<<<<<<<<<< @@ -13282,7 +13289,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":743 + /* "_pydevd_bundle/pydevd_cython.pyx":744 * should_skip = self.should_skip * * plugin_stop = False # <<<<<<<<<<<<<< @@ -13292,17 +13299,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __pyx_v_plugin_stop = Py_False; - /* "_pydevd_bundle/pydevd_cython.pyx":744 + /* "_pydevd_bundle/pydevd_cython.pyx":745 * * plugin_stop = False * if should_skip: # <<<<<<<<<<<<<< * stop = False * */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_should_skip); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_should_skip); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 745; __pyx_clineno = __LINE__; goto __pyx_L190_error;} if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":745 + /* "_pydevd_bundle/pydevd_cython.pyx":746 * plugin_stop = False * if should_skip: * stop = False # <<<<<<<<<<<<<< @@ -13312,35 +13319,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":744 + /* "_pydevd_bundle/pydevd_cython.pyx":745 * * plugin_stop = False * if should_skip: # <<<<<<<<<<<<<< * stop = False * */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":747 + /* "_pydevd_bundle/pydevd_cython.pyx":748 * stop = False * * elif step_cmd == CMD_STEP_INTO: # <<<<<<<<<<<<<< * stop = event in ('line', 'return') * if plugin_manager is not None: */ - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":748 + /* "_pydevd_bundle/pydevd_cython.pyx":749 * * elif step_cmd == CMD_STEP_INTO: * stop = event in ('line', 'return') # <<<<<<<<<<<<<< @@ -13349,24 +13356,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_v_event); __pyx_t_12 = __pyx_v_event; - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_8 != 0); - if (!__pyx_t_10) { - } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L201_bool_binop_done; - } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 749; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_8 = (__pyx_t_10 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L201_bool_binop_done:; + if (!__pyx_t_8) { + } else { + __pyx_t_9 = __pyx_t_8; + goto __pyx_L202_bool_binop_done; + } + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 749; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_10 = (__pyx_t_8 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L202_bool_binop_done:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 748; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 749; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":749 + /* "_pydevd_bundle/pydevd_cython.pyx":750 * elif step_cmd == CMD_STEP_INTO: * stop = event in ('line', 'return') * if plugin_manager is not None: # <<<<<<<<<<<<<< @@ -13374,19 +13381,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if result: */ __pyx_t_9 = (__pyx_v_plugin_manager != Py_None); - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":750 + /* "_pydevd_bundle/pydevd_cython.pyx":751 * stop = event in ('line', 'return') * if plugin_manager is not None: * result = plugin_manager.cmd_step_into(main_debugger, frame, event, self._args, stop_info, stop) # <<<<<<<<<<<<<< * if result: * stop, plugin_stop = result */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_cmd_step_into); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 750; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_cmd_step_into); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 751; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 750; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 751; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_11 = 0; @@ -13400,7 +13407,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_6 = PyTuple_New(6+__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 750; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyTuple_New(6+__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 751; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -13423,24 +13430,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_v_stop); PyTuple_SET_ITEM(__pyx_t_6, 5+__pyx_t_11, __pyx_v_stop); __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 750; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 751; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF_SET(__pyx_v_result, __pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":751 + /* "_pydevd_bundle/pydevd_cython.pyx":752 * if plugin_manager is not None: * result = plugin_manager.cmd_step_into(main_debugger, frame, event, self._args, stop_info, stop) * if result: # <<<<<<<<<<<<<< * stop, plugin_stop = result * */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 751; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - if (__pyx_t_8) { + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":752 + /* "_pydevd_bundle/pydevd_cython.pyx":753 * result = plugin_manager.cmd_step_into(main_debugger, frame, event, self._args, stop_info, stop) * if result: * stop, plugin_stop = result # <<<<<<<<<<<<<< @@ -13457,7 +13464,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -13470,37 +13477,37 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); #else - __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); #endif } else { Py_ssize_t index = -1; - __pyx_t_6 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = Py_TYPE(__pyx_t_6)->tp_iternext; - index = 0; __pyx_t_3 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L205_unpacking_failed; + index = 0; __pyx_t_3 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L206_unpacking_failed; __Pyx_GOTREF(__pyx_t_3); - index = 1; __pyx_t_2 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_2)) goto __pyx_L205_unpacking_failed; + index = 1; __pyx_t_2 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_2)) goto __pyx_L206_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - goto __pyx_L206_unpacking_done; - __pyx_L205_unpacking_failed:; + goto __pyx_L207_unpacking_done; + __pyx_L206_unpacking_failed:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_L206_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_L207_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF_SET(__pyx_v_plugin_stop, __pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":751 + /* "_pydevd_bundle/pydevd_cython.pyx":752 * if plugin_manager is not None: * result = plugin_manager.cmd_step_into(main_debugger, frame, event, self._args, stop_info, stop) * if result: # <<<<<<<<<<<<<< @@ -13509,7 +13516,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":749 + /* "_pydevd_bundle/pydevd_cython.pyx":750 * elif step_cmd == CMD_STEP_INTO: * stop = event in ('line', 'return') * if plugin_manager is not None: # <<<<<<<<<<<<<< @@ -13518,46 +13525,46 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":747 + /* "_pydevd_bundle/pydevd_cython.pyx":748 * stop = False * * elif step_cmd == CMD_STEP_INTO: # <<<<<<<<<<<<<< * stop = event in ('line', 'return') * if plugin_manager is not None: */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":754 + /* "_pydevd_bundle/pydevd_cython.pyx":755 * stop, plugin_stop = result * * elif step_cmd == CMD_STEP_INTO_MY_CODE: # <<<<<<<<<<<<<< * if not main_debugger.not_in_scope(frame.f_code.co_filename): * stop = event == 'line' */ - __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO_MY_CODE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_INTO_MY_CODE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":755 + /* "_pydevd_bundle/pydevd_cython.pyx":756 * * elif step_cmd == CMD_STEP_INTO_MY_CODE: * if not main_debugger.not_in_scope(frame.f_code.co_filename): # <<<<<<<<<<<<<< * stop = event == 'line' * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -13571,40 +13578,40 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_2) { - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_6); } else { - __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL; __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 755; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = ((!__pyx_t_8) != 0); + __pyx_t_9 = ((!__pyx_t_10) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":756 + /* "_pydevd_bundle/pydevd_cython.pyx":757 * elif step_cmd == CMD_STEP_INTO_MY_CODE: * if not main_debugger.not_in_scope(frame.f_code.co_filename): * stop = event == 'line' # <<<<<<<<<<<<<< * * elif step_cmd == CMD_STEP_OVER: */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 756; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 757; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 757; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":755 + /* "_pydevd_bundle/pydevd_cython.pyx":756 * * elif step_cmd == CMD_STEP_INTO_MY_CODE: * if not main_debugger.not_in_scope(frame.f_code.co_filename): # <<<<<<<<<<<<<< @@ -13613,35 +13620,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":754 + /* "_pydevd_bundle/pydevd_cython.pyx":755 * stop, plugin_stop = result * * elif step_cmd == CMD_STEP_INTO_MY_CODE: # <<<<<<<<<<<<<< * if not main_debugger.not_in_scope(frame.f_code.co_filename): * stop = event == 'line' */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":758 + /* "_pydevd_bundle/pydevd_cython.pyx":759 * stop = event == 'line' * * elif step_cmd == CMD_STEP_OVER: # <<<<<<<<<<<<<< * stop = stop_frame is frame and event in ('line', 'return') * */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_OVER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":759 + /* "_pydevd_bundle/pydevd_cython.pyx":760 * * elif step_cmd == CMD_STEP_OVER: * stop = stop_frame is frame and event in ('line', 'return') # <<<<<<<<<<<<<< @@ -13651,69 +13658,69 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_9 = (__pyx_v_stop_frame == __pyx_v_frame); if (__pyx_t_9) { } else { - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_9); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 760; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_t_3; __pyx_t_3 = 0; - goto __pyx_L208_bool_binop_done; + goto __pyx_L209_bool_binop_done; } __Pyx_INCREF(__pyx_v_event); __pyx_t_12 = __pyx_v_event; - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_8 != 0); - if (!__pyx_t_10) { - } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L210_bool_binop_done; - } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 760; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_8 = (__pyx_t_10 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L210_bool_binop_done:; + if (!__pyx_t_8) { + } else { + __pyx_t_9 = __pyx_t_8; + goto __pyx_L211_bool_binop_done; + } + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 760; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_10 = (__pyx_t_8 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L211_bool_binop_done:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_8 = __pyx_t_9; - __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_8); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __pyx_t_9; + __pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_10); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 760; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_t_3; __pyx_t_3 = 0; - __pyx_L208_bool_binop_done:; + __pyx_L209_bool_binop_done:; __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":761 + /* "_pydevd_bundle/pydevd_cython.pyx":762 * stop = stop_frame is frame and event in ('line', 'return') * * if frame.f_code.co_flags & CO_GENERATOR: # <<<<<<<<<<<<<< * if event is 'return': * stop = False */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_flags); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_flags); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_CO_GENERATOR); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_CO_GENERATOR); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyNumber_And(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyNumber_And(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 762; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":762 + /* "_pydevd_bundle/pydevd_cython.pyx":763 * * if frame.f_code.co_flags & CO_GENERATOR: * if event is 'return': # <<<<<<<<<<<<<< * stop = False * */ - __pyx_t_8 = (__pyx_v_event == __pyx_n_s_return); - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = (__pyx_v_event == __pyx_n_s_return); + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":763 + /* "_pydevd_bundle/pydevd_cython.pyx":764 * if frame.f_code.co_flags & CO_GENERATOR: * if event is 'return': * stop = False # <<<<<<<<<<<<<< @@ -13723,7 +13730,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":762 + /* "_pydevd_bundle/pydevd_cython.pyx":763 * * if frame.f_code.co_flags & CO_GENERATOR: * if event is 'return': # <<<<<<<<<<<<<< @@ -13732,7 +13739,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":761 + /* "_pydevd_bundle/pydevd_cython.pyx":762 * stop = stop_frame is frame and event in ('line', 'return') * * if frame.f_code.co_flags & CO_GENERATOR: # <<<<<<<<<<<<<< @@ -13741,7 +13748,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":765 + /* "_pydevd_bundle/pydevd_cython.pyx":766 * stop = False * * if plugin_manager is not None: # <<<<<<<<<<<<<< @@ -13749,19 +13756,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * if result: */ __pyx_t_9 = (__pyx_v_plugin_manager != Py_None); - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":766 + /* "_pydevd_bundle/pydevd_cython.pyx":767 * * if plugin_manager is not None: * result = plugin_manager.cmd_step_over(main_debugger, frame, event, self._args, stop_info, stop) # <<<<<<<<<<<<<< * if result: * stop, plugin_stop = result */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_cmd_step_over); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 766; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_cmd_step_over); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 766; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -13775,7 +13782,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_2 = PyTuple_New(6+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 766; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyTuple_New(6+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -13798,24 +13805,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_v_stop); PyTuple_SET_ITEM(__pyx_t_2, 5+__pyx_t_11, __pyx_v_stop); __pyx_t_3 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 766; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_result, __pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":767 + /* "_pydevd_bundle/pydevd_cython.pyx":768 * if plugin_manager is not None: * result = plugin_manager.cmd_step_over(main_debugger, frame, event, self._args, stop_info, stop) * if result: # <<<<<<<<<<<<<< * stop, plugin_stop = result * */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 767; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - if (__pyx_t_8) { + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_result); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":768 + /* "_pydevd_bundle/pydevd_cython.pyx":769 * result = plugin_manager.cmd_step_over(main_debugger, frame, event, self._args, stop_info, stop) * if result: * stop, plugin_stop = result # <<<<<<<<<<<<<< @@ -13832,7 +13839,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -13845,37 +13852,37 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); #endif } else { Py_ssize_t index = -1; - __pyx_t_2 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyObject_GetIter(__pyx_v_result); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; - index = 0; __pyx_t_6 = __pyx_t_7(__pyx_t_2); if (unlikely(!__pyx_t_6)) goto __pyx_L216_unpacking_failed; + index = 0; __pyx_t_6 = __pyx_t_7(__pyx_t_2); if (unlikely(!__pyx_t_6)) goto __pyx_L217_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_2); if (unlikely(!__pyx_t_5)) goto __pyx_L216_unpacking_failed; + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_2); if (unlikely(!__pyx_t_5)) goto __pyx_L217_unpacking_failed; __Pyx_GOTREF(__pyx_t_5); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_2), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_2), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L217_unpacking_done; - __pyx_L216_unpacking_failed:; + goto __pyx_L218_unpacking_done; + __pyx_L217_unpacking_failed:; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 768; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_L217_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 769; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_L218_unpacking_done:; } __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_plugin_stop, __pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":767 + /* "_pydevd_bundle/pydevd_cython.pyx":768 * if plugin_manager is not None: * result = plugin_manager.cmd_step_over(main_debugger, frame, event, self._args, stop_info, stop) * if result: # <<<<<<<<<<<<<< @@ -13884,7 +13891,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":765 + /* "_pydevd_bundle/pydevd_cython.pyx":766 * stop = False * * if plugin_manager is not None: # <<<<<<<<<<<<<< @@ -13893,35 +13900,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":758 + /* "_pydevd_bundle/pydevd_cython.pyx":759 * stop = event == 'line' * * elif step_cmd == CMD_STEP_OVER: # <<<<<<<<<<<<<< * stop = stop_frame is frame and event in ('line', 'return') * */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":770 + /* "_pydevd_bundle/pydevd_cython.pyx":771 * stop, plugin_stop = result * * elif step_cmd == CMD_SMART_STEP_INTO: # <<<<<<<<<<<<<< * stop = False * if info.pydev_smart_step_stop is frame: */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SMART_STEP_INTO); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SMART_STEP_INTO); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = PyObject_RichCompare(__pyx_t_5, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyObject_RichCompare(__pyx_t_5, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 770; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":771 + /* "_pydevd_bundle/pydevd_cython.pyx":772 * * elif step_cmd == CMD_SMART_STEP_INTO: * stop = False # <<<<<<<<<<<<<< @@ -13931,18 +13938,18 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":772 + /* "_pydevd_bundle/pydevd_cython.pyx":773 * elif step_cmd == CMD_SMART_STEP_INTO: * stop = False * if info.pydev_smart_step_stop is frame: # <<<<<<<<<<<<<< * info.pydev_func_name = '.invalid.' # Must match the type in cython * info.pydev_smart_step_stop = None */ - __pyx_t_8 = (__pyx_v_info->pydev_smart_step_stop == __pyx_v_frame); - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = (__pyx_v_info->pydev_smart_step_stop == __pyx_v_frame); + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":773 + /* "_pydevd_bundle/pydevd_cython.pyx":774 * stop = False * if info.pydev_smart_step_stop is frame: * info.pydev_func_name = '.invalid.' # Must match the type in cython # <<<<<<<<<<<<<< @@ -13955,7 +13962,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_v_info->pydev_func_name); __pyx_v_info->pydev_func_name = __pyx_kp_s_invalid; - /* "_pydevd_bundle/pydevd_cython.pyx":774 + /* "_pydevd_bundle/pydevd_cython.pyx":775 * if info.pydev_smart_step_stop is frame: * info.pydev_func_name = '.invalid.' # Must match the type in cython * info.pydev_smart_step_stop = None # <<<<<<<<<<<<<< @@ -13968,7 +13975,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_v_info->pydev_smart_step_stop); __pyx_v_info->pydev_smart_step_stop = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":772 + /* "_pydevd_bundle/pydevd_cython.pyx":773 * elif step_cmd == CMD_SMART_STEP_INTO: * stop = False * if info.pydev_smart_step_stop is frame: # <<<<<<<<<<<<<< @@ -13977,43 +13984,43 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":776 + /* "_pydevd_bundle/pydevd_cython.pyx":777 * info.pydev_smart_step_stop = None * * if event == 'line' or event == 'exception': # <<<<<<<<<<<<<< * curr_func_name = frame.f_code.co_name * */ - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 776; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_8 != 0); - if (!__pyx_t_10) { - } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L220_bool_binop_done; - } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 776; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_8 = (__pyx_t_10 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L220_bool_binop_done:; + if (!__pyx_t_8) { + } else { + __pyx_t_9 = __pyx_t_8; + goto __pyx_L221_bool_binop_done; + } + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_10 = (__pyx_t_8 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L221_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":777 + /* "_pydevd_bundle/pydevd_cython.pyx":778 * * if event == 'line' or event == 'exception': * curr_func_name = frame.f_code.co_name # <<<<<<<<<<<<<< * * #global context is set with an empty name */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_co_name); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_co_name); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_6)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (!(likely(PyString_CheckExact(__pyx_t_6))||((__pyx_t_6) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_6)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 778; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_XDECREF_SET(__pyx_v_curr_func_name, ((PyObject*)__pyx_t_6)); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":780 + /* "_pydevd_bundle/pydevd_cython.pyx":781 * * #global context is set with an empty name * if curr_func_name in ('?', '') or curr_func_name is None: # <<<<<<<<<<<<<< @@ -14022,31 +14029,31 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_v_curr_func_name); __pyx_t_12 = __pyx_v_curr_func_name; - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_18 = (__pyx_t_10 != 0); + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 781; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_18 = (__pyx_t_8 != 0); if (!__pyx_t_18) { } else { - __pyx_t_8 = __pyx_t_18; - goto __pyx_L225_bool_binop_done; + __pyx_t_10 = __pyx_t_18; + goto __pyx_L226_bool_binop_done; } - __pyx_t_18 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_18 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_18 != 0); - __pyx_t_8 = __pyx_t_10; - __pyx_L225_bool_binop_done:; + __pyx_t_18 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_18 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 781; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_8 = (__pyx_t_18 != 0); + __pyx_t_10 = __pyx_t_8; + __pyx_L226_bool_binop_done:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_10 = (__pyx_t_8 != 0); - if (!__pyx_t_10) { - } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L223_bool_binop_done; - } - __pyx_t_10 = (__pyx_v_curr_func_name == ((PyObject*)Py_None)); __pyx_t_8 = (__pyx_t_10 != 0); - __pyx_t_9 = __pyx_t_8; - __pyx_L223_bool_binop_done:; + if (!__pyx_t_8) { + } else { + __pyx_t_9 = __pyx_t_8; + goto __pyx_L224_bool_binop_done; + } + __pyx_t_8 = (__pyx_v_curr_func_name == ((PyObject*)Py_None)); + __pyx_t_10 = (__pyx_t_8 != 0); + __pyx_t_9 = __pyx_t_10; + __pyx_L224_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":781 + /* "_pydevd_bundle/pydevd_cython.pyx":782 * #global context is set with an empty name * if curr_func_name in ('?', '') or curr_func_name is None: * curr_func_name = '' # <<<<<<<<<<<<<< @@ -14056,7 +14063,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_kp_s_); __Pyx_DECREF_SET(__pyx_v_curr_func_name, __pyx_kp_s_); - /* "_pydevd_bundle/pydevd_cython.pyx":780 + /* "_pydevd_bundle/pydevd_cython.pyx":781 * * #global context is set with an empty name * if curr_func_name in ('?', '') or curr_func_name is None: # <<<<<<<<<<<<<< @@ -14065,18 +14072,18 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":783 + /* "_pydevd_bundle/pydevd_cython.pyx":784 * curr_func_name = '' * * if curr_func_name == info.pydev_func_name: # <<<<<<<<<<<<<< * stop = True * */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_curr_func_name, __pyx_v_info->pydev_func_name, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_curr_func_name, __pyx_v_info->pydev_func_name, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 784; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":784 + /* "_pydevd_bundle/pydevd_cython.pyx":785 * * if curr_func_name == info.pydev_func_name: * stop = True # <<<<<<<<<<<<<< @@ -14086,7 +14093,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_stop, Py_True); - /* "_pydevd_bundle/pydevd_cython.pyx":783 + /* "_pydevd_bundle/pydevd_cython.pyx":784 * curr_func_name = '' * * if curr_func_name == info.pydev_func_name: # <<<<<<<<<<<<<< @@ -14095,7 +14102,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":776 + /* "_pydevd_bundle/pydevd_cython.pyx":777 * info.pydev_smart_step_stop = None * * if event == 'line' or event == 'exception': # <<<<<<<<<<<<<< @@ -14104,104 +14111,104 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":770 + /* "_pydevd_bundle/pydevd_cython.pyx":771 * stop, plugin_stop = result * * elif step_cmd == CMD_SMART_STEP_INTO: # <<<<<<<<<<<<<< * stop = False * if info.pydev_smart_step_stop is frame: */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":786 + /* "_pydevd_bundle/pydevd_cython.pyx":787 * stop = True * * elif step_cmd == CMD_STEP_RETURN: # <<<<<<<<<<<<<< * stop = event == 'return' and stop_frame is frame * */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_STEP_RETURN); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":787 + /* "_pydevd_bundle/pydevd_cython.pyx":788 * * elif step_cmd == CMD_STEP_RETURN: * stop = event == 'return' and stop_frame is frame # <<<<<<<<<<<<<< * * elif step_cmd == CMD_RUN_TO_LINE or step_cmd == CMD_SET_NEXT_STATEMENT: */ - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - if (__pyx_t_8) { + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 788; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + if (__pyx_t_10) { } else { - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_8); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_10); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 788; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __pyx_t_2; __pyx_t_2 = 0; - goto __pyx_L228_bool_binop_done; + goto __pyx_L229_bool_binop_done; } - __pyx_t_8 = (__pyx_v_stop_frame == __pyx_v_frame); - __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_8); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 787; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = (__pyx_v_stop_frame == __pyx_v_frame); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_10); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 788; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __pyx_t_2; __pyx_t_2 = 0; - __pyx_L228_bool_binop_done:; + __pyx_L229_bool_binop_done:; __Pyx_DECREF_SET(__pyx_v_stop, __pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":786 + /* "_pydevd_bundle/pydevd_cython.pyx":787 * stop = True * * elif step_cmd == CMD_STEP_RETURN: # <<<<<<<<<<<<<< * stop = event == 'return' and stop_frame is frame * */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":789 + /* "_pydevd_bundle/pydevd_cython.pyx":790 * stop = event == 'return' and stop_frame is frame * * elif step_cmd == CMD_RUN_TO_LINE or step_cmd == CMD_SET_NEXT_STATEMENT: # <<<<<<<<<<<<<< * stop = False * */ - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_RUN_TO_LINE); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_RUN_TO_LINE); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyObject_RichCompare(__pyx_t_5, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (!__pyx_t_9) { } else { - __pyx_t_8 = __pyx_t_9; - goto __pyx_L230_bool_binop_done; + __pyx_t_10 = __pyx_t_9; + goto __pyx_L231_bool_binop_done; } - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SET_NEXT_STATEMENT); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_CMD_SET_NEXT_STATEMENT); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_6, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 789; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 790; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __pyx_t_9; - __pyx_L230_bool_binop_done:; - if (__pyx_t_8) { + __pyx_t_10 = __pyx_t_9; + __pyx_L231_bool_binop_done:; + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":790 + /* "_pydevd_bundle/pydevd_cython.pyx":791 * * elif step_cmd == CMD_RUN_TO_LINE or step_cmd == CMD_SET_NEXT_STATEMENT: * stop = False # <<<<<<<<<<<<<< @@ -14211,43 +14218,43 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":792 + /* "_pydevd_bundle/pydevd_cython.pyx":793 * stop = False * * if event == 'line' or event == 'exception': # <<<<<<<<<<<<<< * #Yes, we can only act on line events (weird hum?) * #Note: This code is duplicated at pydevd.py */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 792; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_9 != 0); - if (!__pyx_t_10) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 793; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_8 = (__pyx_t_9 != 0); + if (!__pyx_t_8) { } else { - __pyx_t_8 = __pyx_t_10; - goto __pyx_L233_bool_binop_done; + __pyx_t_10 = __pyx_t_8; + goto __pyx_L234_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 792; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_9 = (__pyx_t_10 != 0); - __pyx_t_8 = __pyx_t_9; - __pyx_L233_bool_binop_done:; - if (__pyx_t_8) { + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_exception, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 793; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = __pyx_t_9; + __pyx_L234_bool_binop_done:; + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":796 + /* "_pydevd_bundle/pydevd_cython.pyx":797 * #Note: This code is duplicated at pydevd.py * #Acting on exception events after debugger breaks with exception * curr_func_name = frame.f_code.co_name # <<<<<<<<<<<<<< * * #global context is set with an empty name */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_name); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_name); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (!(likely(PyString_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "str", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 797; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_XDECREF_SET(__pyx_v_curr_func_name, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":799 + /* "_pydevd_bundle/pydevd_cython.pyx":800 * * #global context is set with an empty name * if curr_func_name in ('?', ''): # <<<<<<<<<<<<<< @@ -14256,22 +14263,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __Pyx_INCREF(__pyx_v_curr_func_name); __pyx_t_12 = __pyx_v_curr_func_name; - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_9 != 0); - if (!__pyx_t_10) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s__5, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 800; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_8 = (__pyx_t_9 != 0); + if (!__pyx_t_8) { } else { - __pyx_t_8 = __pyx_t_10; - goto __pyx_L236_bool_binop_done; + __pyx_t_10 = __pyx_t_8; + goto __pyx_L237_bool_binop_done; } - __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_9 = (__pyx_t_10 != 0); - __pyx_t_8 = __pyx_t_9; - __pyx_L236_bool_binop_done:; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_12, __pyx_kp_s_module, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 800; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_10 = __pyx_t_9; + __pyx_L237_bool_binop_done:; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":800 + /* "_pydevd_bundle/pydevd_cython.pyx":801 * #global context is set with an empty name * if curr_func_name in ('?', ''): * curr_func_name = '' # <<<<<<<<<<<<<< @@ -14281,7 +14288,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_kp_s_); __Pyx_DECREF_SET(__pyx_v_curr_func_name, __pyx_kp_s_); - /* "_pydevd_bundle/pydevd_cython.pyx":799 + /* "_pydevd_bundle/pydevd_cython.pyx":800 * * #global context is set with an empty name * if curr_func_name in ('?', ''): # <<<<<<<<<<<<<< @@ -14290,18 +14297,18 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":802 + /* "_pydevd_bundle/pydevd_cython.pyx":803 * curr_func_name = '' * * if curr_func_name == info.pydev_func_name: # <<<<<<<<<<<<<< * line = info.pydev_next_line * if frame.f_lineno == line: */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_curr_func_name, __pyx_v_info->pydev_func_name, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 802; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_8 = (__pyx_t_9 != 0); - if (__pyx_t_8) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_curr_func_name, __pyx_v_info->pydev_func_name, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_10 = (__pyx_t_9 != 0); + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":803 + /* "_pydevd_bundle/pydevd_cython.pyx":804 * * if curr_func_name == info.pydev_func_name: * line = info.pydev_next_line # <<<<<<<<<<<<<< @@ -14311,25 +14318,25 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_13 = __pyx_v_info->pydev_next_line; __pyx_v_line = __pyx_t_13; - /* "_pydevd_bundle/pydevd_cython.pyx":804 + /* "_pydevd_bundle/pydevd_cython.pyx":805 * if curr_func_name == info.pydev_func_name: * line = info.pydev_next_line * if frame.f_lineno == line: # <<<<<<<<<<<<<< * stop = True * else: */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 804; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 804; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 804; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyObject_RichCompare(__pyx_t_2, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 804; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 805; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (__pyx_t_8) { + if (__pyx_t_10) { - /* "_pydevd_bundle/pydevd_cython.pyx":805 + /* "_pydevd_bundle/pydevd_cython.pyx":806 * line = info.pydev_next_line * if frame.f_lineno == line: * stop = True # <<<<<<<<<<<<<< @@ -14339,17 +14346,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_stop, Py_True); - /* "_pydevd_bundle/pydevd_cython.pyx":804 + /* "_pydevd_bundle/pydevd_cython.pyx":805 * if curr_func_name == info.pydev_func_name: * line = info.pydev_next_line * if frame.f_lineno == line: # <<<<<<<<<<<<<< * stop = True * else: */ - goto __pyx_L239; + goto __pyx_L240; } - /* "_pydevd_bundle/pydevd_cython.pyx":807 + /* "_pydevd_bundle/pydevd_cython.pyx":808 * stop = True * else: * if frame.f_trace is None: # <<<<<<<<<<<<<< @@ -14357,26 +14364,26 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * frame.f_lineno = line */ /*else*/ { - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 807; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = (__pyx_t_6 == Py_None); + __pyx_t_10 = (__pyx_t_6 == Py_None); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = (__pyx_t_8 != 0); + __pyx_t_9 = (__pyx_t_10 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":808 + /* "_pydevd_bundle/pydevd_cython.pyx":809 * else: * if frame.f_trace is None: * frame.f_trace = self.trace_dispatch # <<<<<<<<<<<<<< * frame.f_lineno = line * frame.f_trace = None */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 808; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":807 + /* "_pydevd_bundle/pydevd_cython.pyx":808 * stop = True * else: * if frame.f_trace is None: # <<<<<<<<<<<<<< @@ -14385,28 +14392,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":809 + /* "_pydevd_bundle/pydevd_cython.pyx":810 * if frame.f_trace is None: * frame.f_trace = self.trace_dispatch * frame.f_lineno = line # <<<<<<<<<<<<<< * frame.f_trace = None * stop = True */ - __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_line); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 809; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_lineno, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":810 + /* "_pydevd_bundle/pydevd_cython.pyx":811 * frame.f_trace = self.trace_dispatch * frame.f_lineno = line * frame.f_trace = None # <<<<<<<<<<<<<< * stop = True * */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 810; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_frame, __pyx_n_s_f_trace, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 811; __pyx_clineno = __LINE__; goto __pyx_L190_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":811 + /* "_pydevd_bundle/pydevd_cython.pyx":812 * frame.f_lineno = line * frame.f_trace = None * stop = True # <<<<<<<<<<<<<< @@ -14416,9 +14423,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_True); __Pyx_DECREF_SET(__pyx_v_stop, Py_True); } - __pyx_L239:; + __pyx_L240:; - /* "_pydevd_bundle/pydevd_cython.pyx":802 + /* "_pydevd_bundle/pydevd_cython.pyx":803 * curr_func_name = '' * * if curr_func_name == info.pydev_func_name: # <<<<<<<<<<<<<< @@ -14427,7 +14434,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":792 + /* "_pydevd_bundle/pydevd_cython.pyx":793 * stop = False * * if event == 'line' or event == 'exception': # <<<<<<<<<<<<<< @@ -14436,17 +14443,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":789 + /* "_pydevd_bundle/pydevd_cython.pyx":790 * stop = event == 'return' and stop_frame is frame * * elif step_cmd == CMD_RUN_TO_LINE or step_cmd == CMD_SET_NEXT_STATEMENT: # <<<<<<<<<<<<<< * stop = False * */ - goto __pyx_L200; + goto __pyx_L201; } - /* "_pydevd_bundle/pydevd_cython.pyx":814 + /* "_pydevd_bundle/pydevd_cython.pyx":815 * * else: * stop = False # <<<<<<<<<<<<<< @@ -14457,86 +14464,86 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); } - __pyx_L200:; + __pyx_L201:; - /* "_pydevd_bundle/pydevd_cython.pyx":816 + /* "_pydevd_bundle/pydevd_cython.pyx":817 * stop = False * * if stop and step_cmd != -1 and IS_PY3K: # <<<<<<<<<<<<<< * # in Py3k we start script via our custom `execfile` function, and we shouldn't stop there * # while stepping when execution is finished */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - if (__pyx_t_8) { + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 817; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + if (__pyx_t_10) { } else { - __pyx_t_9 = __pyx_t_8; - goto __pyx_L242_bool_binop_done; + __pyx_t_9 = __pyx_t_10; + goto __pyx_L243_bool_binop_done; } - __pyx_t_8 = ((__pyx_v_step_cmd != -1L) != 0); - if (__pyx_t_8) { + __pyx_t_10 = ((__pyx_v_step_cmd != -1L) != 0); + if (__pyx_t_10) { } else { - __pyx_t_9 = __pyx_t_8; - goto __pyx_L242_bool_binop_done; + __pyx_t_9 = __pyx_t_10; + goto __pyx_L243_bool_binop_done; } - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_IS_PY3K); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_IS_PY3K); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 817; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 816; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 817; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = __pyx_t_8; - __pyx_L242_bool_binop_done:; + __pyx_t_9 = __pyx_t_10; + __pyx_L243_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":819 + /* "_pydevd_bundle/pydevd_cython.pyx":820 * # in Py3k we start script via our custom `execfile` function, and we shouldn't stop there * # while stepping when execution is finished * if event == 'return' and hasattr(frame, "f_back") and hasattr(frame.f_back, "f_code"): # <<<<<<<<<<<<<< * back_filename = os.path.basename(frame.f_back.f_code.co_filename) * file_type = get_file_type(back_filename) */ - __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_8 != 0); - if (__pyx_t_10) { - } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L246_bool_binop_done; - } - __pyx_t_10 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_return, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_8 = (__pyx_t_10 != 0); if (__pyx_t_8) { } else { __pyx_t_9 = __pyx_t_8; - goto __pyx_L246_bool_binop_done; + goto __pyx_L247_bool_binop_done; } - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_8 = PyObject_HasAttr(__pyx_t_6, __pyx_n_s_f_code); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = PyObject_HasAttr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_10 = (__pyx_t_8 != 0); - __pyx_t_9 = __pyx_t_10; - __pyx_L246_bool_binop_done:; + if (__pyx_t_10) { + } else { + __pyx_t_9 = __pyx_t_10; + goto __pyx_L247_bool_binop_done; + } + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyObject_HasAttr(__pyx_t_6, __pyx_n_s_f_code); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = (__pyx_t_10 != 0); + __pyx_t_9 = __pyx_t_8; + __pyx_L247_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":820 + /* "_pydevd_bundle/pydevd_cython.pyx":821 * # while stepping when execution is finished * if event == 'return' and hasattr(frame, "f_back") and hasattr(frame.f_back, "f_code"): * back_filename = os.path.basename(frame.f_back.f_code.co_filename) # <<<<<<<<<<<<<< * file_type = get_file_type(back_filename) * if file_type == PYDEV_FILE: */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_basename); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_basename); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_f_code); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; @@ -14550,17 +14557,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_3) { - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_6); } else { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL; __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } @@ -14568,14 +14575,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF_SET(__pyx_v_back_filename, __pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":821 + /* "_pydevd_bundle/pydevd_cython.pyx":822 * if event == 'return' and hasattr(frame, "f_back") and hasattr(frame.f_back, "f_code"): * back_filename = os.path.basename(frame.f_back.f_code.co_filename) * file_type = get_file_type(back_filename) # <<<<<<<<<<<<<< * if file_type == PYDEV_FILE: * stop = False */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_file_type); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_file_type); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { @@ -14588,16 +14595,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_4) { - __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_back_filename); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_back_filename); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); } else { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_back_filename); __Pyx_GIVEREF(__pyx_v_back_filename); PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_back_filename); - __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } @@ -14605,22 +14612,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_v_file_type = __pyx_t_6; __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":822 + /* "_pydevd_bundle/pydevd_cython.pyx":823 * back_filename = os.path.basename(frame.f_back.f_code.co_filename) * file_type = get_file_type(back_filename) * if file_type == PYDEV_FILE: # <<<<<<<<<<<<<< * stop = False * */ - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_PYDEV_FILE); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_PYDEV_FILE); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_5 = PyObject_RichCompare(__pyx_v_file_type, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_v_file_type, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":823 + /* "_pydevd_bundle/pydevd_cython.pyx":824 * file_type = get_file_type(back_filename) * if file_type == PYDEV_FILE: * stop = False # <<<<<<<<<<<<<< @@ -14630,7 +14637,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_False); __Pyx_DECREF_SET(__pyx_v_stop, Py_False); - /* "_pydevd_bundle/pydevd_cython.pyx":822 + /* "_pydevd_bundle/pydevd_cython.pyx":823 * back_filename = os.path.basename(frame.f_back.f_code.co_filename) * file_type = get_file_type(back_filename) * if file_type == PYDEV_FILE: # <<<<<<<<<<<<<< @@ -14639,7 +14646,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":819 + /* "_pydevd_bundle/pydevd_cython.pyx":820 * # in Py3k we start script via our custom `execfile` function, and we shouldn't stop there * # while stepping when execution is finished * if event == 'return' and hasattr(frame, "f_back") and hasattr(frame.f_back, "f_code"): # <<<<<<<<<<<<<< @@ -14648,7 +14655,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":816 + /* "_pydevd_bundle/pydevd_cython.pyx":817 * stop = False * * if stop and step_cmd != -1 and IS_PY3K: # <<<<<<<<<<<<<< @@ -14657,28 +14664,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":825 + /* "_pydevd_bundle/pydevd_cython.pyx":826 * stop = False * * if plugin_stop: # <<<<<<<<<<<<<< * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_plugin_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 825; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_plugin_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L190_error;} if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":826 + /* "_pydevd_bundle/pydevd_cython.pyx":827 * * if plugin_stop: * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) # <<<<<<<<<<<<<< * elif stop: * if event == 'line': */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_stop); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_plugin_manager, __pyx_n_s_stop); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_args_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; __pyx_t_11 = 0; @@ -14692,7 +14699,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_22 = PyTuple_New(7+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = PyTuple_New(7+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_3); __pyx_t_3 = NULL; @@ -14718,54 +14725,54 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di PyTuple_SET_ITEM(__pyx_t_22, 6+__pyx_t_11, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_stopped_on_plugin = __pyx_t_5; __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":825 + /* "_pydevd_bundle/pydevd_cython.pyx":826 * stop = False * * if plugin_stop: # <<<<<<<<<<<<<< * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: */ - goto __pyx_L250; + goto __pyx_L251; } - /* "_pydevd_bundle/pydevd_cython.pyx":827 + /* "_pydevd_bundle/pydevd_cython.pyx":828 * if plugin_stop: * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: # <<<<<<<<<<<<<< * if event == 'line': * self.set_suspend(thread, step_cmd) */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_stop); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L190_error;} if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":828 + /* "_pydevd_bundle/pydevd_cython.pyx":829 * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: * if event == 'line': # <<<<<<<<<<<<<< * self.set_suspend(thread, step_cmd) * self.do_wait_suspend(thread, frame, event, arg) */ - __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_event, __pyx_n_s_line, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":829 + /* "_pydevd_bundle/pydevd_cython.pyx":830 * elif stop: * if event == 'line': * self.set_suspend(thread, step_cmd) # <<<<<<<<<<<<<< * self.do_wait_suspend(thread, frame, event, arg) * else: #return event */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_22 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -14779,7 +14786,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_2 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -14790,20 +14797,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_11, __pyx_t_22); __pyx_t_22 = 0; - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":830 + /* "_pydevd_bundle/pydevd_cython.pyx":831 * if event == 'line': * self.set_suspend(thread, step_cmd) * self.do_wait_suspend(thread, frame, event, arg) # <<<<<<<<<<<<<< * else: #return event * back = frame.f_back */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = NULL; __pyx_t_11 = 0; @@ -14817,7 +14824,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_22 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_2); __pyx_t_2 = NULL; @@ -14834,23 +14841,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_22, 3+__pyx_t_11, __pyx_v_arg); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":828 + /* "_pydevd_bundle/pydevd_cython.pyx":829 * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: * if event == 'line': # <<<<<<<<<<<<<< * self.set_suspend(thread, step_cmd) * self.do_wait_suspend(thread, frame, event, arg) */ - goto __pyx_L251; + goto __pyx_L252; } - /* "_pydevd_bundle/pydevd_cython.pyx":832 + /* "_pydevd_bundle/pydevd_cython.pyx":833 * self.do_wait_suspend(thread, frame, event, arg) * else: #return event * back = frame.f_back # <<<<<<<<<<<<<< @@ -14858,30 +14865,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * #When we get to the pydevd run function, the debugging has actually finished for the main thread */ /*else*/ { - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_back); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF_SET(__pyx_v_back, __pyx_t_5); __pyx_t_5 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":833 + /* "_pydevd_bundle/pydevd_cython.pyx":834 * else: #return event * back = frame.f_back * if back is not None: # <<<<<<<<<<<<<< * #When we get to the pydevd run function, the debugging has actually finished for the main thread * #(note that it can still go on for other threads, but for this one, we just make it finish) */ - __pyx_t_10 = (__pyx_v_back != Py_None); - __pyx_t_9 = (__pyx_t_10 != 0); + __pyx_t_8 = (__pyx_v_back != Py_None); + __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":837 + /* "_pydevd_bundle/pydevd_cython.pyx":838 * #(note that it can still go on for other threads, but for this one, we just make it finish) * #So, just setting it to None should be OK * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) # <<<<<<<<<<<<<< * if base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]: * back = None */ - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_22 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { @@ -14894,16 +14901,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (!__pyx_t_22) { - __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_back); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_back); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); } else { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_22); __pyx_t_22 = NULL; __Pyx_INCREF(__pyx_v_back); __Pyx_GIVEREF(__pyx_v_back); PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_back); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } @@ -14918,7 +14925,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { @@ -14934,36 +14941,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_22); #else - __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_22 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); #endif __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { Py_ssize_t index = -1; - __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_7 = Py_TYPE(__pyx_t_4)->tp_iternext; - index = 0; __pyx_t_6 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_6)) goto __pyx_L253_unpacking_failed; + index = 0; __pyx_t_6 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_6)) goto __pyx_L254_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); - index = 1; __pyx_t_2 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L253_unpacking_failed; + index = 1; __pyx_t_2 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L254_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); - index = 2; __pyx_t_22 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_22)) goto __pyx_L253_unpacking_failed; + index = 2; __pyx_t_22 = __pyx_t_7(__pyx_t_4); if (unlikely(!__pyx_t_22)) goto __pyx_L254_unpacking_failed; __Pyx_GOTREF(__pyx_t_22); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_4), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __pyx_t_7 = NULL; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - goto __pyx_L254_unpacking_done; - __pyx_L253_unpacking_failed:; + goto __pyx_L255_unpacking_done; + __pyx_L254_unpacking_failed:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_L254_unpacking_done:; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_L255_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v__, __pyx_t_6); __pyx_t_6 = 0; @@ -14972,47 +14979,47 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF_SET(__pyx_v_base, __pyx_t_22); __pyx_t_22 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":838 + /* "_pydevd_bundle/pydevd_cython.pyx":839 * #So, just setting it to None should be OK * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]: # <<<<<<<<<<<<<< * back = None * */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;}; + __pyx_t_22 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_22 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;}; __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyObject_RichCompare(__pyx_v_base, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_v_base, __pyx_t_22, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (__pyx_t_10) { + if (__pyx_t_8) { } else { - __pyx_t_9 = __pyx_t_10; - goto __pyx_L256_bool_binop_done; + __pyx_t_9 = __pyx_t_8; + goto __pyx_L257_bool_binop_done; } - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_back, __pyx_n_s_f_code); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_name); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_co_name); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_DEBUG_START); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;}; + __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;}; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = PyObject_RichCompare(__pyx_t_22, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = PyObject_RichCompare(__pyx_t_22, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __pyx_t_10; - __pyx_L256_bool_binop_done:; + __pyx_t_9 = __pyx_t_8; + __pyx_L257_bool_binop_done:; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":839 + /* "_pydevd_bundle/pydevd_cython.pyx":840 * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]: * back = None # <<<<<<<<<<<<<< @@ -15022,32 +15029,32 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_None); __Pyx_DECREF_SET(__pyx_v_back, Py_None); - /* "_pydevd_bundle/pydevd_cython.pyx":838 + /* "_pydevd_bundle/pydevd_cython.pyx":839 * #So, just setting it to None should be OK * _, back_filename, base = get_abs_path_real_path_and_base_from_frame(back) * if base == DEBUG_START[0] and back.f_code.co_name == DEBUG_START[1]: # <<<<<<<<<<<<<< * back = None * */ - goto __pyx_L255; + goto __pyx_L256; } - /* "_pydevd_bundle/pydevd_cython.pyx":841 + /* "_pydevd_bundle/pydevd_cython.pyx":842 * back = None * * elif base == TRACE_PROPERTY: # <<<<<<<<<<<<<< * # We dont want to trace the return event of pydevd_traceproperty (custom property for debugging) * #if we're in a return, we want it to appear to the user in the previous frame! */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_TRACE_PROPERTY); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_TRACE_PROPERTY); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_2 = PyObject_RichCompare(__pyx_v_base, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = PyObject_RichCompare(__pyx_v_base, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":844 + /* "_pydevd_bundle/pydevd_cython.pyx":845 * # We dont want to trace the return event of pydevd_traceproperty (custom property for debugging) * #if we're in a return, we want it to appear to the user in the previous frame! * return None # <<<<<<<<<<<<<< @@ -15057,9 +15064,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; - goto __pyx_L193_try_return; + goto __pyx_L194_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":841 + /* "_pydevd_bundle/pydevd_cython.pyx":842 * back = None * * elif base == TRACE_PROPERTY: # <<<<<<<<<<<<<< @@ -15068,33 +15075,33 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":846 + /* "_pydevd_bundle/pydevd_cython.pyx":847 * return None * * elif pydevd_dont_trace.should_trace_hook is not None: # <<<<<<<<<<<<<< * if not pydevd_dont_trace.should_trace_hook(back, back_filename): * # In this case, we'll have to skip the previous one because it shouldn't be traced. */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 846; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 846; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = (__pyx_t_5 != Py_None); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":847 + /* "_pydevd_bundle/pydevd_cython.pyx":848 * * elif pydevd_dont_trace.should_trace_hook is not None: * if not pydevd_dont_trace.should_trace_hook(back, back_filename): # <<<<<<<<<<<<<< * # In this case, we'll have to skip the previous one because it shouldn't be traced. * # Also, we have to reset the tracing, because if the parent's parent (or some */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pydevd_dont_trace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_should_trace_hook); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -15109,7 +15116,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; @@ -15120,40 +15127,40 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_back_filename); __Pyx_GIVEREF(__pyx_v_back_filename); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_v_back_filename); - __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 848; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_9 = ((!__pyx_t_10) != 0); + __pyx_t_9 = ((!__pyx_t_8) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":853 + /* "_pydevd_bundle/pydevd_cython.pyx":854 * # we should anymore (so, a step in/over/return may not stop anywhere if no parent is traced). * # Related test: _debugger_case17a.py * main_debugger.set_trace_for_frame_and_parents(back, overwrite_prev_trace=True) # <<<<<<<<<<<<<< * return None * */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_set_trace_for_frame_and_parents); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_set_trace_for_frame_and_parents); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_22 = PyTuple_New(1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = PyTuple_New(1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_INCREF(__pyx_v_back); __Pyx_GIVEREF(__pyx_v_back); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_v_back); - __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_overwrite_prev_trace, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L189_error;} - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_22, __pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_overwrite_prev_trace, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __pyx_L190_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_22, __pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 854; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":854 + /* "_pydevd_bundle/pydevd_cython.pyx":855 * # Related test: _debugger_case17a.py * main_debugger.set_trace_for_frame_and_parents(back, overwrite_prev_trace=True) * return None # <<<<<<<<<<<<<< @@ -15163,9 +15170,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_None); __pyx_r = Py_None; - goto __pyx_L193_try_return; + goto __pyx_L194_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":847 + /* "_pydevd_bundle/pydevd_cython.pyx":848 * * elif pydevd_dont_trace.should_trace_hook is not None: * if not pydevd_dont_trace.should_trace_hook(back, back_filename): # <<<<<<<<<<<<<< @@ -15174,7 +15181,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":846 + /* "_pydevd_bundle/pydevd_cython.pyx":847 * return None * * elif pydevd_dont_trace.should_trace_hook is not None: # <<<<<<<<<<<<<< @@ -15182,9 +15189,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * # In this case, we'll have to skip the previous one because it shouldn't be traced. */ } - __pyx_L255:; + __pyx_L256:; - /* "_pydevd_bundle/pydevd_cython.pyx":833 + /* "_pydevd_bundle/pydevd_cython.pyx":834 * else: #return event * back = frame.f_back * if back is not None: # <<<<<<<<<<<<<< @@ -15193,7 +15200,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":856 + /* "_pydevd_bundle/pydevd_cython.pyx":857 * return None * * if back is not None: # <<<<<<<<<<<<<< @@ -15201,19 +15208,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * self.set_suspend(thread, step_cmd) */ __pyx_t_9 = (__pyx_v_back != Py_None); - __pyx_t_10 = (__pyx_t_9 != 0); - if (__pyx_t_10) { + __pyx_t_8 = (__pyx_t_9 != 0); + if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":858 + /* "_pydevd_bundle/pydevd_cython.pyx":859 * if back is not None: * #if we're in a return, we want it to appear to the user in the previous frame! * self.set_suspend(thread, step_cmd) # <<<<<<<<<<<<<< * self.do_wait_suspend(thread, back, event, arg) * else: */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_set_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_22 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = __Pyx_PyInt_From_int(__pyx_v_step_cmd); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); __pyx_t_5 = NULL; __pyx_t_11 = 0; @@ -15227,7 +15234,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_4 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL; @@ -15238,20 +15245,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_11, __pyx_t_22); __pyx_t_22 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":859 + /* "_pydevd_bundle/pydevd_cython.pyx":860 * #if we're in a return, we want it to appear to the user in the previous frame! * self.set_suspend(thread, step_cmd) * self.do_wait_suspend(thread, back, event, arg) # <<<<<<<<<<<<<< * else: * #in jython we may not have a back frame */ - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_do_wait_suspend); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = NULL; __pyx_t_11 = 0; @@ -15265,7 +15272,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_11 = 1; } } - __pyx_t_22 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_22 = PyTuple_New(4+__pyx_t_11); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_4); __pyx_t_4 = NULL; @@ -15282,23 +15289,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_22, 3+__pyx_t_11, __pyx_v_arg); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 859; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_22, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 860; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":856 + /* "_pydevd_bundle/pydevd_cython.pyx":857 * return None * * if back is not None: # <<<<<<<<<<<<<< * #if we're in a return, we want it to appear to the user in the previous frame! * self.set_suspend(thread, step_cmd) */ - goto __pyx_L259; + goto __pyx_L260; } - /* "_pydevd_bundle/pydevd_cython.pyx":862 + /* "_pydevd_bundle/pydevd_cython.pyx":863 * else: * #in jython we may not have a back frame * info.pydev_step_stop = None # <<<<<<<<<<<<<< @@ -15312,7 +15319,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_v_info->pydev_step_stop); __pyx_v_info->pydev_step_stop = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":863 + /* "_pydevd_bundle/pydevd_cython.pyx":864 * #in jython we may not have a back frame * info.pydev_step_stop = None * info.pydev_step_cmd = -1 # <<<<<<<<<<<<<< @@ -15321,24 +15328,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_info->pydev_step_cmd = -1; - /* "_pydevd_bundle/pydevd_cython.pyx":864 + /* "_pydevd_bundle/pydevd_cython.pyx":865 * info.pydev_step_stop = None * info.pydev_step_cmd = -1 * info.pydev_state = STATE_RUN # <<<<<<<<<<<<<< * * except KeyboardInterrupt: */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_RUN); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_STATE_RUN); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 865; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L189_error;} + __pyx_t_13 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 865; __pyx_clineno = __LINE__; goto __pyx_L190_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_info->pydev_state = __pyx_t_13; } - __pyx_L259:; + __pyx_L260:; } - __pyx_L251:; + __pyx_L252:; - /* "_pydevd_bundle/pydevd_cython.pyx":827 + /* "_pydevd_bundle/pydevd_cython.pyx":828 * if plugin_stop: * stopped_on_plugin = plugin_manager.stop(main_debugger, frame, event, self._args, stop_info, arg, step_cmd) * elif stop: # <<<<<<<<<<<<<< @@ -15346,9 +15353,9 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di * self.set_suspend(thread, step_cmd) */ } - __pyx_L250:; + __pyx_L251:; - /* "_pydevd_bundle/pydevd_cython.pyx":728 + /* "_pydevd_bundle/pydevd_cython.pyx":729 * * #step handling. We stop when we hit the right frame * try: # <<<<<<<<<<<<<< @@ -15359,8 +15366,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; - goto __pyx_L196_try_end; - __pyx_L189_error:; + goto __pyx_L197_try_end; + __pyx_L190_error:; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_35); __pyx_t_35 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -15372,7 +15379,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":866 + /* "_pydevd_bundle/pydevd_cython.pyx":867 * info.pydev_state = STATE_RUN * * except KeyboardInterrupt: # <<<<<<<<<<<<<< @@ -15382,12 +15389,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __pyx_t_13 = PyErr_ExceptionMatches(__pyx_builtin_KeyboardInterrupt); if (__pyx_t_13) { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_22) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L191_except_error;} + if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_22) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 867; __pyx_clineno = __LINE__; goto __pyx_L192_except_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_22); - /* "_pydevd_bundle/pydevd_cython.pyx":867 + /* "_pydevd_bundle/pydevd_cython.pyx":868 * * except KeyboardInterrupt: * raise # <<<<<<<<<<<<<< @@ -15399,10 +15406,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ErrRestore(__pyx_t_2, __pyx_t_6, __pyx_t_22); __pyx_t_2 = 0; __pyx_t_6 = 0; __pyx_t_22 = 0; - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 867; __pyx_clineno = __LINE__; goto __pyx_L191_except_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L192_except_error;} } - /* "_pydevd_bundle/pydevd_cython.pyx":868 + /* "_pydevd_bundle/pydevd_cython.pyx":869 * except KeyboardInterrupt: * raise * except: # <<<<<<<<<<<<<< @@ -15411,12 +15418,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_22, &__pyx_t_6, &__pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L191_except_error;} + if (__Pyx_GetException(&__pyx_t_22, &__pyx_t_6, &__pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 869; __pyx_clineno = __LINE__; goto __pyx_L192_except_error;} __Pyx_GOTREF(__pyx_t_22); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_2); - /* "_pydevd_bundle/pydevd_cython.pyx":869 + /* "_pydevd_bundle/pydevd_cython.pyx":870 * raise * except: * try: # <<<<<<<<<<<<<< @@ -15430,16 +15437,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGOTREF(__pyx_t_25); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":870 + /* "_pydevd_bundle/pydevd_cython.pyx":871 * except: * try: * traceback.print_exc() # <<<<<<<<<<<<<< * info.pydev_step_cmd = -1 * except: */ - __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L264_error;} + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L265_error;} __Pyx_GOTREF(__pyx_t_5); - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L264_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L265_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; @@ -15453,16 +15460,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } if (__pyx_t_5) { - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L264_error;} + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L265_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { - __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L264_error;} + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L265_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":871 + /* "_pydevd_bundle/pydevd_cython.pyx":872 * try: * traceback.print_exc() * info.pydev_step_cmd = -1 # <<<<<<<<<<<<<< @@ -15471,7 +15478,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ __pyx_v_info->pydev_step_cmd = -1; - /* "_pydevd_bundle/pydevd_cython.pyx":869 + /* "_pydevd_bundle/pydevd_cython.pyx":870 * raise * except: * try: # <<<<<<<<<<<<<< @@ -15482,8 +15489,8 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0; - goto __pyx_L271_try_end; - __pyx_L264_error:; + goto __pyx_L272_try_end; + __pyx_L265_error:; __Pyx_XDECREF(__pyx_t_26); __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_35); __pyx_t_35 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -15492,7 +15499,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":872 + /* "_pydevd_bundle/pydevd_cython.pyx":873 * traceback.print_exc() * info.pydev_step_cmd = -1 * except: # <<<<<<<<<<<<<< @@ -15501,12 +15508,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.PyDBFrame.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; __pyx_clineno = __LINE__; goto __pyx_L266_except_error;} + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 873; __pyx_clineno = __LINE__; goto __pyx_L267_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_5); - /* "_pydevd_bundle/pydevd_cython.pyx":873 + /* "_pydevd_bundle/pydevd_cython.pyx":874 * info.pydev_step_cmd = -1 * except: * return None # <<<<<<<<<<<<<< @@ -15522,11 +15529,11 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; - goto __pyx_L267_except_return; + goto __pyx_L268_except_return; } - __pyx_L266_except_error:; + __pyx_L267_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":869 + /* "_pydevd_bundle/pydevd_cython.pyx":870 * raise * except: * try: # <<<<<<<<<<<<<< @@ -15537,23 +15544,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); - goto __pyx_L191_except_error; - __pyx_L267_except_return:; + goto __pyx_L192_except_error; + __pyx_L268_except_return:; __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); - goto __pyx_L192_except_return; - __pyx_L271_try_end:; + goto __pyx_L193_except_return; + __pyx_L272_try_end:; } __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - goto __pyx_L190_exception_handled; + goto __pyx_L191_exception_handled; } - __pyx_L191_except_error:; + __pyx_L192_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":728 + /* "_pydevd_bundle/pydevd_cython.pyx":729 * * #step handling. We stop when we hit the right frame * try: # <<<<<<<<<<<<<< @@ -15565,27 +15572,27 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); goto __pyx_L6_error; - __pyx_L193_try_return:; + __pyx_L194_try_return:; __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); goto __pyx_L5_return; - __pyx_L192_except_return:; + __pyx_L193_except_return:; __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); goto __pyx_L5_return; - __pyx_L190_exception_handled:; + __pyx_L191_exception_handled:; __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_16, __pyx_t_15); - __pyx_L196_try_end:; + __pyx_L197_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":876 + /* "_pydevd_bundle/pydevd_cython.pyx":877 * * #if we are quitting, let's stop the tracing * retVal = None # <<<<<<<<<<<<<< @@ -15595,33 +15602,33 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di __Pyx_INCREF(Py_None); __pyx_v_retVal = Py_None; - /* "_pydevd_bundle/pydevd_cython.pyx":877 + /* "_pydevd_bundle/pydevd_cython.pyx":878 * #if we are quitting, let's stop the tracing * retVal = None * if not main_debugger.quitting: # <<<<<<<<<<<<<< * retVal = self.trace_dispatch * */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_quitting); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 877; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_main_debugger, __pyx_n_s_quitting); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 877; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = ((!__pyx_t_10) != 0); + __pyx_t_9 = ((!__pyx_t_8) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":878 + /* "_pydevd_bundle/pydevd_cython.pyx":879 * retVal = None * if not main_debugger.quitting: * retVal = self.trace_dispatch # <<<<<<<<<<<<<< * * return retVal */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L6_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 879; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF_SET(__pyx_v_retVal, __pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":877 + /* "_pydevd_bundle/pydevd_cython.pyx":878 * #if we are quitting, let's stop the tracing * retVal = None * if not main_debugger.quitting: # <<<<<<<<<<<<<< @@ -15630,7 +15637,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di */ } - /* "_pydevd_bundle/pydevd_cython.pyx":880 + /* "_pydevd_bundle/pydevd_cython.pyx":881 * retVal = self.trace_dispatch * * return retVal # <<<<<<<<<<<<<< @@ -15643,7 +15650,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di goto __pyx_L5_return; } - /* "_pydevd_bundle/pydevd_cython.pyx":882 + /* "_pydevd_bundle/pydevd_cython.pyx":883 * return retVal * finally: * info.is_tracing = False # <<<<<<<<<<<<<< @@ -15700,7 +15707,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di } } - /* "_pydevd_bundle/pydevd_cython.pyx":487 + /* "_pydevd_bundle/pydevd_cython.pyx":488 * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * def trace_dispatch(self, frame, str event, arg): # <<<<<<<<<<<<<< @@ -15762,7 +15769,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_16trace_di return __pyx_r; } -/* "_pydevd_bundle/pydevd_cython.pyx":905 +/* "_pydevd_bundle/pydevd_cython.pyx":906 * get_file_type = DONT_TRACE.get * * def trace_dispatch(py_db, frame, event, arg): # <<<<<<<<<<<<<< @@ -15806,21 +15813,21 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_3trace_dispatch(PyObj case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_frame)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "trace_dispatch") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "trace_dispatch") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; @@ -15837,7 +15844,7 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_3trace_dispatch(PyObj } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("trace_dispatch", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -15872,14 +15879,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO int __pyx_clineno = 0; __Pyx_RefNannySetupContext("trace_dispatch", 0); - /* "_pydevd_bundle/pydevd_cython.pyx":907 + /* "_pydevd_bundle/pydevd_cython.pyx":908 * def trace_dispatch(py_db, frame, event, arg): * #try: * t = threadingCurrentThread() # <<<<<<<<<<<<<< * #except: * #this could give an exception (python 2.5 bug), but should not be there anymore... */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threadingCurrentThread); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 907; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threadingCurrentThread); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 908; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -15892,30 +15899,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO } } if (__pyx_t_3) { - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 907; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 908; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 907; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 908; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_t = __pyx_t_1; __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":915 + /* "_pydevd_bundle/pydevd_cython.pyx":916 * #return py_db.trace_dispatch * * if getattr(t, 'pydev_do_not_trace', None): # <<<<<<<<<<<<<< * return None * */ - __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_t, __pyx_n_s_pydev_do_not_trace, Py_None); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __Pyx_GetAttr3(__pyx_v_t, __pyx_n_s_pydev_do_not_trace, Py_None); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 915; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 916; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { - /* "_pydevd_bundle/pydevd_cython.pyx":916 + /* "_pydevd_bundle/pydevd_cython.pyx":917 * * if getattr(t, 'pydev_do_not_trace', None): * return None # <<<<<<<<<<<<<< @@ -15927,7 +15934,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __pyx_r = Py_None; goto __pyx_L0; - /* "_pydevd_bundle/pydevd_cython.pyx":915 + /* "_pydevd_bundle/pydevd_cython.pyx":916 * #return py_db.trace_dispatch * * if getattr(t, 'pydev_do_not_trace', None): # <<<<<<<<<<<<<< @@ -15936,7 +15943,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO */ } - /* "_pydevd_bundle/pydevd_cython.pyx":918 + /* "_pydevd_bundle/pydevd_cython.pyx":919 * return None * * try: # <<<<<<<<<<<<<< @@ -15950,19 +15957,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":919 + /* "_pydevd_bundle/pydevd_cython.pyx":920 * * try: * additional_info = t.additional_info # <<<<<<<<<<<<<< * if additional_info is None: * raise AttributeError() */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_additional_info); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L4_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_additional_info); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L4_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_additional_info = __pyx_t_1; __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":920 + /* "_pydevd_bundle/pydevd_cython.pyx":921 * try: * additional_info = t.additional_info * if additional_info is None: # <<<<<<<<<<<<<< @@ -15973,20 +15980,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __pyx_t_8 = (__pyx_t_4 != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":921 + /* "_pydevd_bundle/pydevd_cython.pyx":922 * additional_info = t.additional_info * if additional_info is None: * raise AttributeError() # <<<<<<<<<<<<<< * except: * additional_info = t.additional_info = PyDBAdditionalThreadInfo() */ - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_AttributeError); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 921; __pyx_clineno = __LINE__; goto __pyx_L4_error;} + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_builtin_AttributeError); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L4_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 921; __pyx_clineno = __LINE__; goto __pyx_L4_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L4_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":920 + /* "_pydevd_bundle/pydevd_cython.pyx":921 * try: * additional_info = t.additional_info * if additional_info is None: # <<<<<<<<<<<<<< @@ -15995,7 +16002,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO */ } - /* "_pydevd_bundle/pydevd_cython.pyx":918 + /* "_pydevd_bundle/pydevd_cython.pyx":919 * return None * * try: # <<<<<<<<<<<<<< @@ -16012,7 +16019,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":922 + /* "_pydevd_bundle/pydevd_cython.pyx":923 * if additional_info is None: * raise AttributeError() * except: # <<<<<<<<<<<<<< @@ -16021,23 +16028,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.trace_dispatch", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_3); - /* "_pydevd_bundle/pydevd_cython.pyx":923 + /* "_pydevd_bundle/pydevd_cython.pyx":924 * raise AttributeError() * except: * additional_info = t.additional_info = PyDBAdditionalThreadInfo() # <<<<<<<<<<<<<< * * thread_tracer = ThreadTracer((py_db, t, additional_info)) */ - __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} + __pyx_t_9 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_9); __Pyx_XDECREF_SET(__pyx_v_additional_info, __pyx_t_9); - if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_additional_info, __pyx_t_9) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_additional_info, __pyx_t_9) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -16046,7 +16053,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO } __pyx_L6_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":918 + /* "_pydevd_bundle/pydevd_cython.pyx":919 * return None * * try: # <<<<<<<<<<<<<< @@ -16066,14 +16073,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __pyx_L11_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":925 + /* "_pydevd_bundle/pydevd_cython.pyx":926 * additional_info = t.additional_info = PyDBAdditionalThreadInfo() * * thread_tracer = ThreadTracer((py_db, t, additional_info)) # <<<<<<<<<<<<<< * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * t._tracer = thread_tracer # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough). */ - __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v_py_db); __Pyx_GIVEREF(__pyx_v_py_db); @@ -16084,36 +16091,36 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __Pyx_INCREF(__pyx_v_additional_info); __Pyx_GIVEREF(__pyx_v_additional_info); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_additional_info); - __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_14_pydevd_bundle_13pydevd_cython_ThreadTracer), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 925; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_14_pydevd_bundle_13pydevd_cython_ThreadTracer), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_thread_tracer = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_ThreadTracer *)__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":927 + /* "_pydevd_bundle/pydevd_cython.pyx":928 * thread_tracer = ThreadTracer((py_db, t, additional_info)) * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * t._tracer = thread_tracer # Hack for cython to keep it alive while the thread is alive (just the method in the SetTrace is not enough). # <<<<<<<<<<<<<< * # ELSE * # ENDIF */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_tracer, ((PyObject *)__pyx_v_thread_tracer)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_tracer, ((PyObject *)__pyx_v_thread_tracer)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":930 + /* "_pydevd_bundle/pydevd_cython.pyx":931 * # ELSE * # ENDIF * SetTrace(thread_tracer.__call__) # <<<<<<<<<<<<<< * return thread_tracer.__call__(frame, event, arg) * */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SetTrace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_SetTrace); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_thread_tracer), __pyx_n_s_call_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_thread_tracer), __pyx_n_s_call_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -16126,24 +16133,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO } } if (!__pyx_t_9) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":931 + /* "_pydevd_bundle/pydevd_cython.pyx":932 * # ENDIF * SetTrace(thread_tracer.__call__) * return thread_tracer.__call__(frame, event, arg) # <<<<<<<<<<<<<< @@ -16151,7 +16158,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_thread_tracer), __pyx_n_s_call_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_thread_tracer), __pyx_n_s_call_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = NULL; __pyx_t_11 = 0; @@ -16165,7 +16172,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __pyx_t_11 = 1; } } - __pyx_t_1 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10); __pyx_t_10 = NULL; @@ -16179,7 +16186,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_11, __pyx_v_arg); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 931; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 932; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; @@ -16187,7 +16194,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO __pyx_t_3 = 0; goto __pyx_L0; - /* "_pydevd_bundle/pydevd_cython.pyx":905 + /* "_pydevd_bundle/pydevd_cython.pyx":906 * get_file_type = DONT_TRACE.get * * def trace_dispatch(py_db, frame, event, arg): # <<<<<<<<<<<<<< @@ -16213,7 +16220,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_2trace_dispatch(CYTHO return __pyx_r; } -/* "_pydevd_bundle/pydevd_cython.pyx":936 +/* "_pydevd_bundle/pydevd_cython.pyx":937 * cdef class ThreadTracer: * cdef public tuple _args; * def __init__(self, tuple args): # <<<<<<<<<<<<<< @@ -16249,7 +16256,7 @@ static int __pyx_pw_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_1__init__(Py else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; @@ -16260,13 +16267,13 @@ static int __pyx_pw_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_1__init__(Py } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; - if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyTuple_Type), 1, "args", 1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer___init__(((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_ThreadTracer *)__pyx_v_self), __pyx_v_args); /* function exit code */ @@ -16283,7 +16290,7 @@ static int __pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer___init__(str __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__", 0); - /* "_pydevd_bundle/pydevd_cython.pyx":937 + /* "_pydevd_bundle/pydevd_cython.pyx":938 * cdef public tuple _args; * def __init__(self, tuple args): * self._args = args # <<<<<<<<<<<<<< @@ -16296,7 +16303,7 @@ static int __pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer___init__(str __Pyx_DECREF(__pyx_v_self->_args); __pyx_v_self->_args = __pyx_v_args; - /* "_pydevd_bundle/pydevd_cython.pyx":936 + /* "_pydevd_bundle/pydevd_cython.pyx":937 * cdef class ThreadTracer: * cdef public tuple _args; * def __init__(self, tuple args): # <<<<<<<<<<<<<< @@ -16310,7 +16317,7 @@ static int __pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer___init__(str return __pyx_r; } -/* "_pydevd_bundle/pydevd_cython.pyx":945 +/* "_pydevd_bundle/pydevd_cython.pyx":946 * * * def __call__(self, frame, event, arg): # <<<<<<<<<<<<<< @@ -16355,16 +16362,16 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_3__cal case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_event)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 946; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arg)) != 0)) kw_args--; else { - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 946; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__call__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 946; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; @@ -16379,7 +16386,7 @@ static PyObject *__pyx_pw_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_3__cal } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __Pyx_RaiseArgtupleInvalid("__call__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 946; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); @@ -16422,7 +16429,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__call__", 0); - /* "_pydevd_bundle/pydevd_cython.pyx":964 + /* "_pydevd_bundle/pydevd_cython.pyx":965 * cdef PyDBAdditionalThreadInfo additional_info; * # ENDIF * py_db, t, additional_info = self._args # <<<<<<<<<<<<<< @@ -16441,7 +16448,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); @@ -16451,18 +16458,18 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); #else - __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); #endif __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else { - __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } - if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 965; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_py_db = __pyx_t_2; __pyx_t_2 = 0; __pyx_v_t = __pyx_t_3; @@ -16470,7 +16477,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_v_additional_info = ((struct __pyx_obj_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo *)__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":966 + /* "_pydevd_bundle/pydevd_cython.pyx":967 * py_db, t, additional_info = self._args * * try: # <<<<<<<<<<<<<< @@ -16484,34 +16491,34 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XGOTREF(__pyx_t_7); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":967 + /* "_pydevd_bundle/pydevd_cython.pyx":968 * * try: * if py_db._finish_debugging_session: # <<<<<<<<<<<<<< * if not py_db._termination_event_set: * #that was not working very well because jython gave some socket errors */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 967; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 967; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":968 + /* "_pydevd_bundle/pydevd_cython.pyx":969 * try: * if py_db._finish_debugging_session: * if not py_db._termination_event_set: # <<<<<<<<<<<<<< * #that was not working very well because jython gave some socket errors * try: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_termination_event_set); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_termination_event_set); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 968; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 969; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = ((!__pyx_t_8) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":970 + /* "_pydevd_bundle/pydevd_cython.pyx":971 * if not py_db._termination_event_set: * #that was not working very well because jython gave some socket errors * try: # <<<<<<<<<<<<<< @@ -16525,28 +16532,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":971 + /* "_pydevd_bundle/pydevd_cython.pyx":972 * #that was not working very well because jython gave some socket errors * try: * if py_db.output_checker is None: # <<<<<<<<<<<<<< * kill_all_pydev_threads() * except: */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_output_checker); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 971; __pyx_clineno = __LINE__; goto __pyx_L13_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_output_checker); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 972; __pyx_clineno = __LINE__; goto __pyx_L13_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = (__pyx_t_1 == Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_8 = (__pyx_t_9 != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":972 + /* "_pydevd_bundle/pydevd_cython.pyx":973 * try: * if py_db.output_checker is None: * kill_all_pydev_threads() # <<<<<<<<<<<<<< * except: * traceback.print_exc() */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_kill_all_pydev_threads); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 972; __pyx_clineno = __LINE__; goto __pyx_L13_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_kill_all_pydev_threads); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L13_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { @@ -16559,16 +16566,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (__pyx_t_3) { - __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 972; __pyx_clineno = __LINE__; goto __pyx_L13_error;} + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L13_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { - __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 972; __pyx_clineno = __LINE__; goto __pyx_L13_error;} + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L13_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":971 + /* "_pydevd_bundle/pydevd_cython.pyx":972 * #that was not working very well because jython gave some socket errors * try: * if py_db.output_checker is None: # <<<<<<<<<<<<<< @@ -16577,7 +16584,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":970 + /* "_pydevd_bundle/pydevd_cython.pyx":971 * if not py_db._termination_event_set: * #that was not working very well because jython gave some socket errors * try: # <<<<<<<<<<<<<< @@ -16595,7 +16602,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":973 + /* "_pydevd_bundle/pydevd_cython.pyx":974 * if py_db.output_checker is None: * kill_all_pydev_threads() * except: # <<<<<<<<<<<<<< @@ -16604,21 +16611,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} + if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_3); - /* "_pydevd_bundle/pydevd_cython.pyx":974 + /* "_pydevd_bundle/pydevd_cython.pyx":975 * kill_all_pydev_threads() * except: * traceback.print_exc() # <<<<<<<<<<<<<< * py_db._termination_event_set = True * return None */ - __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} + __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} __Pyx_GOTREF(__pyx_t_13); - __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} + __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; @@ -16632,10 +16639,10 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (__pyx_t_13) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_t_13); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } else { - __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_14); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_14); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; @@ -16647,7 +16654,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } __pyx_L15_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":970 + /* "_pydevd_bundle/pydevd_cython.pyx":971 * if not py_db._termination_event_set: * #that was not working very well because jython gave some socket errors * try: # <<<<<<<<<<<<<< @@ -16667,16 +16674,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_L20_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":975 + /* "_pydevd_bundle/pydevd_cython.pyx":976 * except: * traceback.print_exc() * py_db._termination_event_set = True # <<<<<<<<<<<<<< * return None * */ - if (__Pyx_PyObject_SetAttrStr(__pyx_v_py_db, __pyx_n_s_termination_event_set, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + if (__Pyx_PyObject_SetAttrStr(__pyx_v_py_db, __pyx_n_s_termination_event_set, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 976; __pyx_clineno = __LINE__; goto __pyx_L3_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":968 + /* "_pydevd_bundle/pydevd_cython.pyx":969 * try: * if py_db._finish_debugging_session: * if not py_db._termination_event_set: # <<<<<<<<<<<<<< @@ -16685,7 +16692,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":976 + /* "_pydevd_bundle/pydevd_cython.pyx":977 * traceback.print_exc() * py_db._termination_event_set = True * return None # <<<<<<<<<<<<<< @@ -16697,7 +16704,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":967 + /* "_pydevd_bundle/pydevd_cython.pyx":968 * * try: * if py_db._finish_debugging_session: # <<<<<<<<<<<<<< @@ -16706,14 +16713,14 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":979 + /* "_pydevd_bundle/pydevd_cython.pyx":980 * * # if thread is not alive, cancel trace_dispatch processing * if not is_thread_alive(t): # <<<<<<<<<<<<<< * py_db._process_thread_not_alive(get_thread_id(t)) * return None # suspend tracing */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_thread_alive); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_thread_alive); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { @@ -16726,35 +16733,35 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_1) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __pyx_t_1 = NULL; __Pyx_INCREF(__pyx_v_t); __Pyx_GIVEREF(__pyx_v_t); PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_t); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_9 = ((!__pyx_t_8) != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":980 + /* "_pydevd_bundle/pydevd_cython.pyx":981 * # if thread is not alive, cancel trace_dispatch processing * if not is_thread_alive(t): * py_db._process_thread_not_alive(get_thread_id(t)) # <<<<<<<<<<<<<< * return None # suspend tracing * */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_process_thread_not_alive); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_process_thread_not_alive); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_thread_id); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_thread_id); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { @@ -16767,16 +16774,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_14) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_t); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_t); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); } else { - __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_14); __pyx_t_14 = NULL; __Pyx_INCREF(__pyx_v_t); __Pyx_GIVEREF(__pyx_v_t); PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_t); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } @@ -16792,24 +16799,24 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_1) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_1); __pyx_t_1 = NULL; __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_2); __pyx_t_2 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":981 + /* "_pydevd_bundle/pydevd_cython.pyx":982 * if not is_thread_alive(t): * py_db._process_thread_not_alive(get_thread_id(t)) * return None # suspend tracing # <<<<<<<<<<<<<< @@ -16821,7 +16828,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":979 + /* "_pydevd_bundle/pydevd_cython.pyx":980 * * # if thread is not alive, cancel trace_dispatch processing * if not is_thread_alive(t): # <<<<<<<<<<<<<< @@ -16830,7 +16837,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":983 + /* "_pydevd_bundle/pydevd_cython.pyx":984 * return None # suspend tracing * * try: # <<<<<<<<<<<<<< @@ -16844,29 +16851,29 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":985 + /* "_pydevd_bundle/pydevd_cython.pyx":986 * try: * # Make fast path faster! * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] # <<<<<<<<<<<<<< * except: * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame) */ - __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L25_error;} + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L25_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_frame, __pyx_n_s_f_code); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L25_error;} + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_co_filename); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L25_error;}; + __pyx_t_4 = PyObject_GetItem(__pyx_t_3, __pyx_t_13); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L25_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; - if (!(likely(PyTuple_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_4)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L25_error;} + if (!(likely(PyTuple_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_4)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __pyx_v_abs_path_real_path_and_base = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":983 + /* "_pydevd_bundle/pydevd_cython.pyx":984 * return None # suspend tracing * * try: # <<<<<<<<<<<<<< @@ -16886,7 +16893,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":986 + /* "_pydevd_bundle/pydevd_cython.pyx":987 * # Make fast path faster! * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] * except: # <<<<<<<<<<<<<< @@ -16895,19 +16902,19 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ /*except:*/ { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_13, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_13, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_3); - /* "_pydevd_bundle/pydevd_cython.pyx":987 + /* "_pydevd_bundle/pydevd_cython.pyx":988 * abs_path_real_path_and_base = NORM_PATHS_AND_BASE_CONTAINER[frame.f_code.co_filename] * except: * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame) # <<<<<<<<<<<<<< * * if py_db.thread_analyser is not None: */ - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { @@ -16920,21 +16927,21 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_14) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_frame); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_frame); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_2); } else { - __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_14); __pyx_t_14 = NULL; __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_v_frame); - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (!(likely(PyTuple_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} + if (!(likely(PyTuple_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_2)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_XDECREF_SET(__pyx_v_abs_path_real_path_and_base, ((PyObject*)__pyx_t_2)); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; @@ -16944,7 +16951,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } __pyx_L27_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":983 + /* "_pydevd_bundle/pydevd_cython.pyx":984 * return None # suspend tracing * * try: # <<<<<<<<<<<<<< @@ -16964,30 +16971,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_L32_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":989 + /* "_pydevd_bundle/pydevd_cython.pyx":990 * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame) * * if py_db.thread_analyser is not None: # <<<<<<<<<<<<<< * py_db.thread_analyser.log_event(frame) * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_thread_analyser); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 989; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_thread_analyser); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_9 = (__pyx_t_3 != Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = (__pyx_t_9 != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":990 + /* "_pydevd_bundle/pydevd_cython.pyx":991 * * if py_db.thread_analyser is not None: * py_db.thread_analyser.log_event(frame) # <<<<<<<<<<<<<< * * if py_db.asyncio_analyser is not None: */ - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_thread_analyser); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_thread_analyser); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_log_event); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_13, __pyx_n_s_log_event); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; @@ -17001,23 +17008,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_13) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_frame); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_frame); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_13); __pyx_t_13 = NULL; __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_frame); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":989 + /* "_pydevd_bundle/pydevd_cython.pyx":990 * abs_path_real_path_and_base = get_abs_path_real_path_and_base_from_frame(frame) * * if py_db.thread_analyser is not None: # <<<<<<<<<<<<<< @@ -17026,30 +17033,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":992 + /* "_pydevd_bundle/pydevd_cython.pyx":993 * py_db.thread_analyser.log_event(frame) * * if py_db.asyncio_analyser is not None: # <<<<<<<<<<<<<< * py_db.asyncio_analyser.log_event(frame) * */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_asyncio_analyser); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 992; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_asyncio_analyser); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = (__pyx_t_3 != Py_None); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":993 + /* "_pydevd_bundle/pydevd_cython.pyx":994 * * if py_db.asyncio_analyser is not None: * py_db.asyncio_analyser.log_event(frame) # <<<<<<<<<<<<<< * * file_type = get_file_type(abs_path_real_path_and_base[-1]) #we don't want to debug threading or anything related to pydevd */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_asyncio_analyser); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_asyncio_analyser); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log_event); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log_event); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -17063,23 +17070,23 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_4) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_frame); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_frame); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_INCREF(__pyx_v_frame); __Pyx_GIVEREF(__pyx_v_frame); PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_frame); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":992 + /* "_pydevd_bundle/pydevd_cython.pyx":993 * py_db.thread_analyser.log_event(frame) * * if py_db.asyncio_analyser is not None: # <<<<<<<<<<<<<< @@ -17088,20 +17095,20 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":995 + /* "_pydevd_bundle/pydevd_cython.pyx":996 * py_db.asyncio_analyser.log_event(frame) * * file_type = get_file_type(abs_path_real_path_and_base[-1]) #we don't want to debug threading or anything related to pydevd # <<<<<<<<<<<<<< * * if file_type is not None: */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_file_type); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_get_file_type); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); if (unlikely(__pyx_v_abs_path_real_path_and_base == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } - __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; + __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; __Pyx_GOTREF(__pyx_t_13); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { @@ -17114,17 +17121,17 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_4) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_13); __pyx_t_13 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 995; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 996; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } @@ -17132,7 +17139,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_v_file_type = __pyx_t_3; __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":997 + /* "_pydevd_bundle/pydevd_cython.pyx":998 * file_type = get_file_type(abs_path_real_path_and_base[-1]) #we don't want to debug threading or anything related to pydevd * * if file_type is not None: # <<<<<<<<<<<<<< @@ -17143,33 +17150,33 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_8 = (__pyx_t_9 != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":998 + /* "_pydevd_bundle/pydevd_cython.pyx":999 * * if file_type is not None: * if file_type == 1: # inlining LIB_FILE = 1 # <<<<<<<<<<<<<< * if py_db.not_in_scope(abs_path_real_path_and_base[1]): * # print('skipped: trace_dispatch (not in scope)', base, frame.f_lineno, event, frame.f_code.co_name, file_type) */ - __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_file_type, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 998; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_file_type, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 998; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":999 + /* "_pydevd_bundle/pydevd_cython.pyx":1000 * if file_type is not None: * if file_type == 1: # inlining LIB_FILE = 1 * if py_db.not_in_scope(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< * # print('skipped: trace_dispatch (not in scope)', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * return None */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); if (unlikely(__pyx_v_abs_path_real_path_and_base == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } - __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { @@ -17182,26 +17189,26 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_13) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_13); __pyx_t_13 = NULL; __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1001 + /* "_pydevd_bundle/pydevd_cython.pyx":1002 * if py_db.not_in_scope(abs_path_real_path_and_base[1]): * # print('skipped: trace_dispatch (not in scope)', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * return None # <<<<<<<<<<<<<< @@ -17213,7 +17220,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":999 + /* "_pydevd_bundle/pydevd_cython.pyx":1000 * if file_type is not None: * if file_type == 1: # inlining LIB_FILE = 1 * if py_db.not_in_scope(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< @@ -17222,7 +17229,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":998 + /* "_pydevd_bundle/pydevd_cython.pyx":999 * * if file_type is not None: * if file_type == 1: # inlining LIB_FILE = 1 # <<<<<<<<<<<<<< @@ -17232,7 +17239,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal goto __pyx_L38; } - /* "_pydevd_bundle/pydevd_cython.pyx":1004 + /* "_pydevd_bundle/pydevd_cython.pyx":1005 * else: * # print('skipped: trace_dispatch', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * return None # <<<<<<<<<<<<<< @@ -17247,7 +17254,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } __pyx_L38:; - /* "_pydevd_bundle/pydevd_cython.pyx":997 + /* "_pydevd_bundle/pydevd_cython.pyx":998 * file_type = get_file_type(abs_path_real_path_and_base[-1]) #we don't want to debug threading or anything related to pydevd * * if file_type is not None: # <<<<<<<<<<<<<< @@ -17256,7 +17263,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1006 + /* "_pydevd_bundle/pydevd_cython.pyx":1007 * return None * * if additional_info.pydev_step_cmd != -1: # <<<<<<<<<<<<<< @@ -17266,29 +17273,29 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_8 = ((__pyx_v_additional_info->pydev_step_cmd != -1L) != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1007 + /* "_pydevd_bundle/pydevd_cython.pyx":1008 * * if additional_info.pydev_step_cmd != -1: * if py_db.is_filter_enabled and py_db.is_ignored_by_filters(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< * # ignore files matching stepping filters * return None */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_filter_enabled); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_filter_enabled); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L42_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_ignored_by_filters); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_ignored_by_filters); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); if (unlikely(__pyx_v_abs_path_real_path_and_base == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } - __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; + __pyx_t_4 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { @@ -17301,28 +17308,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_1) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_1); __pyx_t_1 = NULL; __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_13, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L42_bool_binop_done:; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1009 + /* "_pydevd_bundle/pydevd_cython.pyx":1010 * if py_db.is_filter_enabled and py_db.is_ignored_by_filters(abs_path_real_path_and_base[1]): * # ignore files matching stepping filters * return None # <<<<<<<<<<<<<< @@ -17334,7 +17341,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":1007 + /* "_pydevd_bundle/pydevd_cython.pyx":1008 * * if additional_info.pydev_step_cmd != -1: * if py_db.is_filter_enabled and py_db.is_ignored_by_filters(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< @@ -17343,29 +17350,29 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1010 + /* "_pydevd_bundle/pydevd_cython.pyx":1011 * # ignore files matching stepping filters * return None * if py_db.is_filter_libraries and py_db.not_in_scope(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< * # ignore library files while stepping * return None */ - __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_filter_libraries); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_is_filter_libraries); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_9) { } else { __pyx_t_8 = __pyx_t_9; goto __pyx_L45_bool_binop_done; } - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_not_in_scope); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); if (unlikely(__pyx_v_abs_path_real_path_and_base == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } - __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; + __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; __Pyx_GOTREF(__pyx_t_13); __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { @@ -17378,28 +17385,28 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_4) { - __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_13); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_GOTREF(__pyx_t_3); } else { - __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL; __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_t_13); __pyx_t_13 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1010; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1011; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_8 = __pyx_t_9; __pyx_L45_bool_binop_done:; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1012 + /* "_pydevd_bundle/pydevd_cython.pyx":1013 * if py_db.is_filter_libraries and py_db.not_in_scope(abs_path_real_path_and_base[1]): * # ignore library files while stepping * return None # <<<<<<<<<<<<<< @@ -17411,7 +17418,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":1010 + /* "_pydevd_bundle/pydevd_cython.pyx":1011 * # ignore files matching stepping filters * return None * if py_db.is_filter_libraries and py_db.not_in_scope(abs_path_real_path_and_base[1]): # <<<<<<<<<<<<<< @@ -17420,7 +17427,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1006 + /* "_pydevd_bundle/pydevd_cython.pyx":1007 * return None * * if additional_info.pydev_step_cmd != -1: # <<<<<<<<<<<<<< @@ -17429,7 +17436,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1015 + /* "_pydevd_bundle/pydevd_cython.pyx":1016 * * # print('trace_dispatch', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * if additional_info.is_tracing: # <<<<<<<<<<<<<< @@ -17439,7 +17446,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_8 = (__pyx_v_additional_info->is_tracing != 0); if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1016 + /* "_pydevd_bundle/pydevd_cython.pyx":1017 * # print('trace_dispatch', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * if additional_info.is_tracing: * return None #we don't wan't to trace code invoked from pydevd_frame.trace_dispatch # <<<<<<<<<<<<<< @@ -17451,7 +17458,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_r = Py_None; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":1015 + /* "_pydevd_bundle/pydevd_cython.pyx":1016 * * # print('trace_dispatch', base, frame.f_lineno, event, frame.f_code.co_name, file_type) * if additional_info.is_tracing: # <<<<<<<<<<<<<< @@ -17460,7 +17467,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1022 + /* "_pydevd_bundle/pydevd_cython.pyx":1023 * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * # Note that on Cython we only support more modern idioms (no support for < Python 2.5) * return PyDBFrame((py_db, abs_path_real_path_and_base[1], additional_info, t)).trace_dispatch(frame, event, arg) # <<<<<<<<<<<<<< @@ -17468,15 +17475,15 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal * # return additional_info.create_db_frame((py_db, abs_path_real_path_and_base[1], additional_info, t, frame)).trace_dispatch(frame, event, arg) */ __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_PyDBFrame); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_PyDBFrame); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); if (unlikely(__pyx_v_abs_path_real_path_and_base == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } - __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; + __pyx_t_13 = __Pyx_GetItemInt_Tuple(__pyx_v_abs_path_real_path_and_base, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_13 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;}; __Pyx_GOTREF(__pyx_t_13); - __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_py_db); __Pyx_GIVEREF(__pyx_v_py_db); @@ -17501,22 +17508,22 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (!__pyx_t_13) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else { - __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __pyx_t_13 = NULL; __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_trace_dispatch); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; @@ -17531,7 +17538,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_16 = 1; } } - __pyx_t_15 = PyTuple_New(3+__pyx_t_16); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_15 = PyTuple_New(3+__pyx_t_16); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_2) { __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2); __pyx_t_2 = NULL; @@ -17545,7 +17552,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_16, __pyx_v_arg); - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1022; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -17553,7 +17560,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_3 = 0; goto __pyx_L7_try_return; - /* "_pydevd_bundle/pydevd_cython.pyx":966 + /* "_pydevd_bundle/pydevd_cython.pyx":967 * py_db, t, additional_info = self._args * * try: # <<<<<<<<<<<<<< @@ -17570,7 +17577,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":1027 + /* "_pydevd_bundle/pydevd_cython.pyx":1028 * # ENDIF * * except SystemExit: # <<<<<<<<<<<<<< @@ -17580,12 +17587,12 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_SystemExit); if (__pyx_t_17) { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1028; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_15); - /* "_pydevd_bundle/pydevd_cython.pyx":1028 + /* "_pydevd_bundle/pydevd_cython.pyx":1029 * * except SystemExit: * return None # <<<<<<<<<<<<<< @@ -17601,7 +17608,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal goto __pyx_L6_except_return; } - /* "_pydevd_bundle/pydevd_cython.pyx":1030 + /* "_pydevd_bundle/pydevd_cython.pyx":1031 * return None * * except Exception: # <<<<<<<<<<<<<< @@ -17611,25 +17618,25 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_Exception); if (__pyx_t_17) { __Pyx_AddTraceback("_pydevd_bundle.pydevd_cython.ThreadTracer.__call__", __pyx_clineno, __pyx_lineno, __pyx_filename); - if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_1, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1030; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_1, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_3); - /* "_pydevd_bundle/pydevd_cython.pyx":1031 + /* "_pydevd_bundle/pydevd_cython.pyx":1032 * * except Exception: * if py_db._finish_debugging_session: # <<<<<<<<<<<<<< * return None # Don't log errors when we're shutting down. * # Log it */ - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_py_db, __pyx_n_s_finish_debugging_session); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_8) { - /* "_pydevd_bundle/pydevd_cython.pyx":1032 + /* "_pydevd_bundle/pydevd_cython.pyx":1033 * except Exception: * if py_db._finish_debugging_session: * return None # Don't log errors when we're shutting down. # <<<<<<<<<<<<<< @@ -17644,7 +17651,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L6_except_return; - /* "_pydevd_bundle/pydevd_cython.pyx":1031 + /* "_pydevd_bundle/pydevd_cython.pyx":1032 * * except Exception: * if py_db._finish_debugging_session: # <<<<<<<<<<<<<< @@ -17653,7 +17660,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1034 + /* "_pydevd_bundle/pydevd_cython.pyx":1035 * return None # Don't log errors when we're shutting down. * # Log it * try: # <<<<<<<<<<<<<< @@ -17667,30 +17674,30 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { - /* "_pydevd_bundle/pydevd_cython.pyx":1035 + /* "_pydevd_bundle/pydevd_cython.pyx":1036 * # Log it * try: * if traceback is not None: # <<<<<<<<<<<<<< * # This can actually happen during the interpreter shutdown in Python 2.7 * traceback.print_exc() */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L53_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L53_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = (__pyx_t_2 != Py_None); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = (__pyx_t_8 != 0); if (__pyx_t_9) { - /* "_pydevd_bundle/pydevd_cython.pyx":1037 + /* "_pydevd_bundle/pydevd_cython.pyx":1038 * if traceback is not None: * # This can actually happen during the interpreter shutdown in Python 2.7 * traceback.print_exc() # <<<<<<<<<<<<<< * except: * # Error logging? We're really in the interpreter shutdown... */ - __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L53_error;} + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_traceback); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1038; __pyx_clineno = __LINE__; goto __pyx_L53_error;} __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L53_error;} + __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_print_exc); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1038; __pyx_clineno = __LINE__; goto __pyx_L53_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; @@ -17704,16 +17711,16 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal } } if (__pyx_t_4) { - __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L53_error;} + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1038; __pyx_clineno = __LINE__; goto __pyx_L53_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { - __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L53_error;} + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1038; __pyx_clineno = __LINE__; goto __pyx_L53_error;} } __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":1035 + /* "_pydevd_bundle/pydevd_cython.pyx":1036 * # Log it * try: * if traceback is not None: # <<<<<<<<<<<<<< @@ -17722,7 +17729,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal */ } - /* "_pydevd_bundle/pydevd_cython.pyx":1034 + /* "_pydevd_bundle/pydevd_cython.pyx":1035 * return None # Don't log errors when we're shutting down. * # Log it * try: # <<<<<<<<<<<<<< @@ -17740,7 +17747,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":1038 + /* "_pydevd_bundle/pydevd_cython.pyx":1039 * # This can actually happen during the interpreter shutdown in Python 2.7 * traceback.print_exc() * except: # <<<<<<<<<<<<<< @@ -17759,7 +17766,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal __pyx_L60_try_end:; } - /* "_pydevd_bundle/pydevd_cython.pyx":1042 + /* "_pydevd_bundle/pydevd_cython.pyx":1043 * # (https://github.com/fabioz/PyDev.Debugger/issues/8) * pass * return None # <<<<<<<<<<<<<< @@ -17775,7 +17782,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal goto __pyx_L5_except_error; __pyx_L5_except_error:; - /* "_pydevd_bundle/pydevd_cython.pyx":966 + /* "_pydevd_bundle/pydevd_cython.pyx":967 * py_db, t, additional_info = self._args * * try: # <<<<<<<<<<<<<< @@ -17801,7 +17808,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal goto __pyx_L0; } - /* "_pydevd_bundle/pydevd_cython.pyx":945 + /* "_pydevd_bundle/pydevd_cython.pyx":946 * * * def __call__(self, frame, event, arg): # <<<<<<<<<<<<<< @@ -17831,7 +17838,7 @@ static PyObject *__pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__cal return __pyx_r; } -/* "_pydevd_bundle/pydevd_cython.pyx":935 +/* "_pydevd_bundle/pydevd_cython.pyx":936 * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * cdef class ThreadTracer: * cdef public tuple _args; # <<<<<<<<<<<<<< @@ -17889,7 +17896,7 @@ static int __pyx_pf_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_5_args_2__se const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); - if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(PyTuple_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v_value)->tp_name), 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 936; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = __pyx_v_value; __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); @@ -18720,13 +18727,13 @@ static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_AssertionError = __Pyx_GetBuiltinName(__pyx_n_s_AssertionError); if (!__pyx_builtin_AssertionError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 434; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_GeneratorExit = __Pyx_GetBuiltinName(__pyx_n_s_GeneratorExit); if (!__pyx_builtin_GeneratorExit) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_eval = __Pyx_GetBuiltinName(__pyx_n_s_eval); if (!__pyx_builtin_eval) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 643; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_KeyboardInterrupt = __Pyx_GetBuiltinName(__pyx_n_s_KeyboardInterrupt); if (!__pyx_builtin_KeyboardInterrupt) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 921; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_SystemExit = __Pyx_GetBuiltinName(__pyx_n_s_SystemExit); if (!__pyx_builtin_SystemExit) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - __pyx_builtin_Exception = __Pyx_GetBuiltinName(__pyx_n_s_Exception); if (!__pyx_builtin_Exception) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1030; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_StopIteration = __Pyx_GetBuiltinName(__pyx_n_s_StopIteration); if (!__pyx_builtin_StopIteration) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_GeneratorExit = __Pyx_GetBuiltinName(__pyx_n_s_GeneratorExit); if (!__pyx_builtin_GeneratorExit) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 538; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_eval = __Pyx_GetBuiltinName(__pyx_n_s_eval); if (!__pyx_builtin_eval) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_KeyboardInterrupt = __Pyx_GetBuiltinName(__pyx_n_s_KeyboardInterrupt); if (!__pyx_builtin_KeyboardInterrupt) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 867; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_SystemExit = __Pyx_GetBuiltinName(__pyx_n_s_SystemExit); if (!__pyx_builtin_SystemExit) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1028; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_Exception = __Pyx_GetBuiltinName(__pyx_n_s_Exception); if (!__pyx_builtin_Exception) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; @@ -18769,14 +18776,14 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); - /* "_pydevd_bundle/pydevd_cython.pyx":650 + /* "_pydevd_bundle/pydevd_cython.pyx":651 * if type(condition) != type(''): * if hasattr(condition, 'encode'): * condition = condition.encode('utf-8') # <<<<<<<<<<<<<< * * msg = 'Error while evaluating expression: %s\n' % (condition,) */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_utf_8); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_utf_8); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); @@ -18921,29 +18928,29 @@ static int __Pyx_InitCachedConstants(void) { __Pyx_GIVEREF(__pyx_tuple__26); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_user_work_ultimate_communi, __pyx_n_s_manage_return_values, 465, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 465; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":487 + /* "_pydevd_bundle/pydevd_cython.pyx":488 * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * def trace_dispatch(self, frame, str event, arg): # <<<<<<<<<<<<<< * cdef str filename; * cdef bint is_exception_event; */ - __pyx_tuple__29 = PyTuple_Pack(43, __pyx_n_s_self, __pyx_n_s_frame, __pyx_n_s_event, __pyx_n_s_arg, __pyx_n_s_filename, __pyx_n_s_is_exception_event, __pyx_n_s_has_exception_breakpoints, __pyx_n_s_can_skip, __pyx_n_s_info, __pyx_n_s_step_cmd, __pyx_n_s_line, __pyx_n_s_curr_func_name, __pyx_n_s_exist_result, __pyx_n_s_main_debugger, __pyx_n_s_thread, __pyx_n_s_need_trace_return, __pyx_n_s_plugin_manager, __pyx_n_s_flag, __pyx_n_s_stop_frame, __pyx_n_s_breakpoints_for_file, __pyx_n_s_breakpoint, __pyx_n_s_stop_info, __pyx_n_s_stop, __pyx_n_s_bp_type, __pyx_n_s_new_frame, __pyx_n_s_result, __pyx_n_s_condition, __pyx_n_s_val, __pyx_n_s_msg, __pyx_n_s_etype, __pyx_n_s_value, __pyx_n_s_tb, __pyx_n_s_error, __pyx_n_s_stack, __pyx_n_s_back, __pyx_n_s__28, __pyx_n_s_back_filename, __pyx_n_s_base, __pyx_n_s_should_skip, __pyx_n_s_plugin_stop, __pyx_n_s_file_type, __pyx_n_s_stopped_on_plugin, __pyx_n_s_retVal); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__29 = PyTuple_Pack(43, __pyx_n_s_self, __pyx_n_s_frame, __pyx_n_s_event, __pyx_n_s_arg, __pyx_n_s_filename, __pyx_n_s_is_exception_event, __pyx_n_s_has_exception_breakpoints, __pyx_n_s_can_skip, __pyx_n_s_info, __pyx_n_s_step_cmd, __pyx_n_s_line, __pyx_n_s_curr_func_name, __pyx_n_s_exist_result, __pyx_n_s_main_debugger, __pyx_n_s_thread, __pyx_n_s_need_trace_return, __pyx_n_s_plugin_manager, __pyx_n_s_flag, __pyx_n_s_stop_frame, __pyx_n_s_breakpoints_for_file, __pyx_n_s_breakpoint, __pyx_n_s_stop_info, __pyx_n_s_stop, __pyx_n_s_bp_type, __pyx_n_s_new_frame, __pyx_n_s_result, __pyx_n_s_condition, __pyx_n_s_val, __pyx_n_s_msg, __pyx_n_s_etype, __pyx_n_s_value, __pyx_n_s_tb, __pyx_n_s_error, __pyx_n_s_stack, __pyx_n_s_back, __pyx_n_s__28, __pyx_n_s_back_filename, __pyx_n_s_base, __pyx_n_s_should_skip, __pyx_n_s_plugin_stop, __pyx_n_s_file_type, __pyx_n_s_stopped_on_plugin, __pyx_n_s_retVal); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); - __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(4, 0, 43, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_user_work_ultimate_communi, __pyx_n_s_trace_dispatch, 487, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(4, 0, 43, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_user_work_ultimate_communi, __pyx_n_s_trace_dispatch, 488, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L1_error;} - /* "_pydevd_bundle/pydevd_cython.pyx":905 + /* "_pydevd_bundle/pydevd_cython.pyx":906 * get_file_type = DONT_TRACE.get * * def trace_dispatch(py_db, frame, event, arg): # <<<<<<<<<<<<<< * #try: * t = threadingCurrentThread() */ - __pyx_tuple__31 = PyTuple_Pack(7, __pyx_n_s_py_db, __pyx_n_s_frame, __pyx_n_s_event, __pyx_n_s_arg, __pyx_n_s_t, __pyx_n_s_additional_info, __pyx_n_s_thread_tracer); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_tuple__31 = PyTuple_Pack(7, __pyx_n_s_py_db, __pyx_n_s_frame, __pyx_n_s_event, __pyx_n_s_arg, __pyx_n_s_t, __pyx_n_s_additional_info, __pyx_n_s_thread_tracer); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); - __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_user_work_ultimate_communi, __pyx_n_s_trace_dispatch, 905, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_user_work_ultimate_communi, __pyx_n_s_trace_dispatch, 906, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; @@ -19058,11 +19065,11 @@ PyMODINIT_FUNC PyInit_pydevd_cython(void) __pyx_type_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "PyDBAdditionalThreadInfo", (PyObject *)&__pyx_type_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo = &__pyx_type_14_pydevd_bundle_13pydevd_cython_PyDBAdditionalThreadInfo; - if (PyType_Ready(&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyType_Ready(&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer.tp_print = 0; #if CYTHON_COMPILING_IN_CPYTHON { - PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer, "__call__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer, "__call__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) { __pyx_wrapperbase_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__call__ = *((PyWrapperDescrObject *)wrapper)->d_base; __pyx_wrapperbase_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__call__.doc = __pyx_doc_14_pydevd_bundle_13pydevd_cython_12ThreadTracer_2__call__; @@ -19070,7 +19077,7 @@ PyMODINIT_FUNC PyInit_pydevd_cython(void) } } #endif - if (PyObject_SetAttrString(__pyx_m, "ThreadTracer", (PyObject *)&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 934; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "ThreadTracer", (PyObject *)&__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_14_pydevd_bundle_13pydevd_cython_ThreadTracer = &__pyx_type_14_pydevd_bundle_13pydevd_cython_ThreadTracer; /*--- Type import code ---*/ /*--- Variable import code ---*/ @@ -19986,16 +19993,16 @@ PyMODINIT_FUNC PyInit_pydevd_cython(void) if (PyObject_SetItem(__pyx_t_6, __pyx_n_s_manage_return_values, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 465; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":487 + /* "_pydevd_bundle/pydevd_cython.pyx":488 * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) * def trace_dispatch(self, frame, str event, arg): # <<<<<<<<<<<<<< * cdef str filename; * cdef bint is_exception_event; */ - __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_17trace_dispatch, 0, __pyx_n_s_PyDBFrame_trace_dispatch, NULL, __pyx_n_s_pydevd_bundle_pydevd_cython, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_CyFunction_NewEx(&__pyx_mdef_14_pydevd_bundle_13pydevd_cython_9PyDBFrame_17trace_dispatch, 0, __pyx_n_s_PyDBFrame_trace_dispatch, NULL, __pyx_n_s_pydevd_bundle_pydevd_cython, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyObject_SetItem(__pyx_t_6, __pyx_n_s_trace_dispatch, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetItem(__pyx_t_6, __pyx_n_s_trace_dispatch, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 488; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_bundle/pydevd_cython.pyx":239 @@ -20011,131 +20018,131 @@ PyMODINIT_FUNC PyInit_pydevd_cython(void) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":886 + /* "_pydevd_bundle/pydevd_cython.pyx":887 * #end trace_dispatch * * import traceback # <<<<<<<<<<<<<< * * from _pydev_bundle.pydev_is_thread_alive import is_thread_alive */ - __pyx_t_6 = __Pyx_Import(__pyx_n_s_traceback, 0, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_Import(__pyx_n_s_traceback, 0, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 887; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_traceback, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_traceback, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 887; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":888 + /* "_pydevd_bundle/pydevd_cython.pyx":889 * import traceback * * from _pydev_bundle.pydev_is_thread_alive import is_thread_alive # <<<<<<<<<<<<<< * from _pydev_imps._pydev_saved_modules import threading * from _pydevd_bundle.pydevd_constants import get_thread_id */ - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_n_s_is_thread_alive); __Pyx_GIVEREF(__pyx_n_s_is_thread_alive); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_is_thread_alive); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydev_bundle_pydev_is_thread_al, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydev_bundle_pydev_is_thread_al, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_is_thread_alive); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_is_thread_alive); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_thread_alive, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_thread_alive, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":889 + /* "_pydevd_bundle/pydevd_cython.pyx":890 * * from _pydev_bundle.pydev_is_thread_alive import is_thread_alive * from _pydev_imps._pydev_saved_modules import threading # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_constants import get_thread_id * from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_threading); __Pyx_GIVEREF(__pyx_n_s_threading); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_threading); - __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydev_imps__pydev_saved_modules, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydev_imps__pydev_saved_modules, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 889; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":890 + /* "_pydevd_bundle/pydevd_cython.pyx":891 * from _pydev_bundle.pydev_is_thread_alive import is_thread_alive * from _pydev_imps._pydev_saved_modules import threading * from _pydevd_bundle.pydevd_constants import get_thread_id # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE * from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads */ - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_n_s_get_thread_id); __Pyx_GIVEREF(__pyx_n_s_get_thread_id); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_get_thread_id); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_constants, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_constants, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_thread_id); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_get_thread_id); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_thread_id, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 890; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_thread_id, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":891 + /* "_pydevd_bundle/pydevd_cython.pyx":892 * from _pydev_imps._pydev_saved_modules import threading * from _pydevd_bundle.pydevd_constants import get_thread_id * from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_DONT_TRACE); __Pyx_GIVEREF(__pyx_n_s_DONT_TRACE); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_DONT_TRACE); - __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_dont_trace, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_dont_trace, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_DONT_TRACE); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_DONT_TRACE); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_DONT_TRACE, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 891; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_DONT_TRACE, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":892 + /* "_pydevd_bundle/pydevd_cython.pyx":893 * from _pydevd_bundle.pydevd_constants import get_thread_id * from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE * from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads # <<<<<<<<<<<<<< * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER * from _pydevd_bundle.pydevd_tracing import SetTrace */ - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_n_s_kill_all_pydev_threads); __Pyx_GIVEREF(__pyx_n_s_kill_all_pydev_threads); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_kill_all_pydev_threads); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_kill_all_p, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_kill_all_p, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_kill_all_pydev_threads); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_kill_all_pydev_threads); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_kill_all_pydev_threads, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_kill_all_pydev_threads, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":893 + /* "_pydevd_bundle/pydevd_cython.pyx":894 * from _pydevd_bundle.pydevd_dont_trace_files import DONT_TRACE * from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER # <<<<<<<<<<<<<< * from _pydevd_bundle.pydevd_tracing import SetTrace * */ - __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_get_abs_path_real_path_and_base); __Pyx_GIVEREF(__pyx_n_s_get_abs_path_real_path_and_base); @@ -20143,80 +20150,80 @@ PyMODINIT_FUNC PyInit_pydevd_cython(void) __Pyx_INCREF(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); __Pyx_GIVEREF(__pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); - __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydevd_file_utils, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_Import(__pyx_n_s_pydevd_file_utils, __pyx_t_2, -1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_get_abs_path_real_path_and_base); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_abs_path_real_path_and_base, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_abs_path_real_path_and_base, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_6, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 893; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_NORM_PATHS_AND_BASE_CONTAINER, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":894 + /* "_pydevd_bundle/pydevd_cython.pyx":895 * from _pydevd_bundle.pydevd_kill_all_pydevd_threads import kill_all_pydev_threads * from pydevd_file_utils import get_abs_path_real_path_and_base_from_frame, NORM_PATHS_AND_BASE_CONTAINER * from _pydevd_bundle.pydevd_tracing import SetTrace # <<<<<<<<<<<<<< * * # IFDEF CYTHON -- DONT EDIT THIS FILE (it is automatically generated) */ - __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_n_s_SetTrace); __Pyx_GIVEREF(__pyx_n_s_SetTrace); PyList_SET_ITEM(__pyx_t_6, 0, __pyx_n_s_SetTrace); - __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_tracing, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_Import(__pyx_n_s_pydevd_bundle_pydevd_tracing, __pyx_t_6, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SetTrace); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SetTrace); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_SetTrace, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 894; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SetTrace, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 895; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":902 + /* "_pydevd_bundle/pydevd_cython.pyx":903 * # ENDIF * * threadingCurrentThread = threading.currentThread # <<<<<<<<<<<<<< * get_file_type = DONT_TRACE.get * */ - __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 902; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_currentThread); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 902; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_currentThread); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_threadingCurrentThread, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 902; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_threadingCurrentThread, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":903 + /* "_pydevd_bundle/pydevd_cython.pyx":904 * * threadingCurrentThread = threading.currentThread * get_file_type = DONT_TRACE.get # <<<<<<<<<<<<<< * * def trace_dispatch(py_db, frame, event, arg): */ - __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_DONT_TRACE); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_DONT_TRACE); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 904; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 904; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_file_type, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 903; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_file_type, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 904; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "_pydevd_bundle/pydevd_cython.pyx":905 + /* "_pydevd_bundle/pydevd_cython.pyx":906 * get_file_type = DONT_TRACE.get * * def trace_dispatch(py_db, frame, event, arg): # <<<<<<<<<<<<<< * #try: * t = threadingCurrentThread() */ - __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_14_pydevd_bundle_13pydevd_cython_3trace_dispatch, NULL, __pyx_n_s_pydevd_bundle_pydevd_cython); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_14_pydevd_bundle_13pydevd_cython_3trace_dispatch, NULL, __pyx_n_s_pydevd_bundle_pydevd_cython); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_trace_dispatch, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 905; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_trace_dispatch, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 906; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "_pydevd_bundle/pydevd_cython.pyx":1 diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython.pyx b/python/helpers/pydev/_pydevd_bundle/pydevd_cython.pyx index 510f36714498..7d41cd404c6e 100644 --- a/python/helpers/pydev/_pydevd_bundle/pydevd_cython.pyx +++ b/python/helpers/pydev/_pydevd_bundle/pydevd_cython.pyx @@ -470,7 +470,8 @@ class PyDBFrame: # No longer cdef because object was dying when only a reference if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): frame.f_back.f_locals[RETURN_VALUES_PREFIX + name] = arg if main_debugger.remove_return_values_flag: - # show return values was turned off, we should remove them from locals dict + # Showing return values was turned off, we should remove them from locals dict. + # The values can be in the current frame or in the back one for var_name in dict_keys(frame.f_locals): if var_name.startswith(RETURN_VALUES_PREFIX): dict_pop(frame.f_locals, var_name) @@ -565,7 +566,7 @@ class PyDBFrame: # No longer cdef because object was dying when only a reference if can_skip and main_debugger.show_return_values: # trace function for showing return values after step over - if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: + if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: can_skip = False # Let's check to see if we are in a function that has a breakpoint. If we don't have a breakpoint, diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_32.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_32.pyd index 813cdbb35f66..144b270ff8ec 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_32.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_32.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_64.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_64.pyd index de420a75ed40..163bae17c0f8 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_64.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_27_64.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_32.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_32.pyd index c17eed5f44a6..4718b84ddad5 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_32.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_32.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_64.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_64.pyd index 5019b98f4163..4232a260e982 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_64.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_34_64.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_32.cp35-win32.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_32.cp35-win32.pyd index dc5c2e5cbba6..5708d314ad76 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_32.cp35-win32.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_32.cp35-win32.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_64.cp35-win_amd64.pyd b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_64.cp35-win_amd64.pyd index 6a2678d7976c..afa232aa17f8 100644 Binary files a/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_64.cp35-win_amd64.pyd and b/python/helpers/pydev/_pydevd_bundle/pydevd_cython_win32_35_64.cp35-win_amd64.pyd differ diff --git a/python/helpers/pydev/_pydevd_bundle/pydevd_frame.py b/python/helpers/pydev/_pydevd_bundle/pydevd_frame.py index 7f9facc302b7..b34c9f33b29d 100644 --- a/python/helpers/pydev/_pydevd_bundle/pydevd_frame.py +++ b/python/helpers/pydev/_pydevd_bundle/pydevd_frame.py @@ -273,7 +273,8 @@ class PyDBFrame: # No longer cdef because object was dying when only a reference if hasattr(frame, "f_back") and hasattr(frame.f_back, "f_locals"): frame.f_back.f_locals[RETURN_VALUES_PREFIX + name] = arg if main_debugger.remove_return_values_flag: - # show return values was turned off, we should remove them from locals dict + # Showing return values was turned off, we should remove them from locals dict. + # The values can be in the current frame or in the back one for var_name in dict_keys(frame.f_locals): if var_name.startswith(RETURN_VALUES_PREFIX): dict_pop(frame.f_locals, var_name) @@ -368,7 +369,7 @@ class PyDBFrame: # No longer cdef because object was dying when only a reference if can_skip and main_debugger.show_return_values: # trace function for showing return values after step over - if info.pydev_step_cmd == CMD_STEP_OVER and frame.f_back == info.pydev_step_stop: + if info.pydev_step_cmd == CMD_STEP_OVER and hasattr(frame, "f_back") and frame.f_back == info.pydev_step_stop: can_skip = False # Let's check to see if we are in a function that has a breakpoint. If we don't have a breakpoint, diff --git a/python/src/com/jetbrains/python/debugger/PyDebugProcess.java b/python/src/com/jetbrains/python/debugger/PyDebugProcess.java index 42efef86d400..13958bb96ba5 100644 --- a/python/src/com/jetbrains/python/debugger/PyDebugProcess.java +++ b/python/src/com/jetbrains/python/debugger/PyDebugProcess.java @@ -309,7 +309,7 @@ public class PyDebugProcess extends XDebugProcess implements IPyDebugProcess, Pr public void init() { getSession().rebuildViews(); registerBreakpoints(); - setShowReturnValues(PyDebuggerSettings.getInstance().WATCH_RETURN_VALUES); + setShowReturnValues(PyDebuggerSettings.getInstance().watchReturnValues); } @Override @@ -413,17 +413,17 @@ public class PyDebugProcess extends XDebugProcess implements IPyDebugProcess, Pr @NotNull DefaultActionGroup topToolbar, @NotNull DefaultActionGroup settings) { super.registerAdditionalActions(leftToolbar, topToolbar, settings); - settings.add(new WatchLastMethodReturnValueAction(this)); + settings.add(new WatchReturnValuesAction(this)); } - private static class WatchLastMethodReturnValueAction extends ToggleAction { + private static class WatchReturnValuesAction extends ToggleAction { private volatile boolean myWatchesReturnValues; private final PyDebugProcess myProcess; private final String myText; - public WatchLastMethodReturnValueAction(@NotNull PyDebugProcess debugProcess) { + public WatchReturnValuesAction(@NotNull PyDebugProcess debugProcess) { super("", "Enables watching executed functions return values", null); - myWatchesReturnValues = PyDebuggerSettings.getInstance().WATCH_RETURN_VALUES; + myWatchesReturnValues = PyDebuggerSettings.getInstance().watchReturnValues; myProcess = debugProcess; myText = "Show Return Values"; } @@ -444,7 +444,7 @@ public class PyDebugProcess extends XDebugProcess implements IPyDebugProcess, Pr @Override public void setSelected(AnActionEvent e, boolean watch) { myWatchesReturnValues = watch; - PyDebuggerSettings.getInstance().WATCH_RETURN_VALUES = watch; + PyDebuggerSettings.getInstance().watchReturnValues = watch; final Project project = e.getProject(); if (project != null) { myProcess.setShowReturnValues(myWatchesReturnValues); diff --git a/python/src/com/jetbrains/python/debugger/settings/PyDebuggerSettings.java b/python/src/com/jetbrains/python/debugger/settings/PyDebuggerSettings.java index 9534bcf04b51..3f0509eb4086 100644 --- a/python/src/com/jetbrains/python/debugger/settings/PyDebuggerSettings.java +++ b/python/src/com/jetbrains/python/debugger/settings/PyDebuggerSettings.java @@ -38,7 +38,7 @@ public class PyDebuggerSettings extends XDebuggerSettings im private boolean mySteppingFiltersEnabled; private @NotNull List mySteppingFilters; public static final String FILTERS_DIVIDER = ";"; - public volatile boolean WATCH_RETURN_VALUES = false; + public volatile boolean watchReturnValues = false; public PyDebuggerSettings() { super("python"); diff --git a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java index 178d7bcc9740..861ec198c165 100644 --- a/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java +++ b/python/testSrc/com/jetbrains/env/python/PythonDebuggerTest.java @@ -918,13 +918,13 @@ public class PythonDebuggerTest extends PyEnvTestCase { toggleBreakpoint(getScriptPath(), 7); toggleBreakpoint(getScriptPath(), 11); final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance(); - debuggerSettings.WATCH_RETURN_VALUES = true; + debuggerSettings.watchReturnValues = true; } @Override public void doFinally() { final PyDebuggerSettings debuggerSettings = PyDebuggerSettings.getInstance(); - debuggerSettings.WATCH_RETURN_VALUES = false; + debuggerSettings.watchReturnValues = false; } @Override diff --git a/resources-en/src/inspectionDescriptions/SimplifyStreamApiCallChains.html b/resources-en/src/inspectionDescriptions/SimplifyStreamApiCallChains.html new file mode 100644 index 000000000000..0d7dfa65a8ea --- /dev/null +++ b/resources-en/src/inspectionDescriptions/SimplifyStreamApiCallChains.html @@ -0,0 +1,7 @@ + + +This inspection reports redundant stream API call chains. +
+For example, Collection.stream().forEach() can be replaced with Collection.forEach() + + \ No newline at end of file diff --git a/resources/src/META-INF/IdeaPlugin.xml b/resources/src/META-INF/IdeaPlugin.xml index dc9dd6fbf534..bbd5a7ec7e69 100644 --- a/resources/src/META-INF/IdeaPlugin.xml +++ b/resources/src/META-INF/IdeaPlugin.xml @@ -786,6 +786,11 @@ groupKey="group.names.language.level.specific.issues.and.migration.aids" enabledByDefault="true" level="WARNING" implementationClass="com.intellij.codeInspection.java18api.Java8CollectionsApiInspection" displayName="Collection usages can be replaced with single method"/> + com.intellij.codeInsight.daemon.quickFix.RedundantLambdaParameterTypeIntention @@ -1078,6 +1083,8 @@ implementationClass="com.intellij.codeInsight.generation.surroundWith.JavaStatementsSurroundDescriptor"/> + @@ -1222,7 +1229,7 @@ + order="after sameModule, before inResolveScope"/> diff --git a/xml/tests/testData/xml/WrongRegExpCategory.xsd b/xml/tests/testData/xml/WrongRegExpCategory.xsd index d6359d706f1b..7730bca00f39 100644 --- a/xml/tests/testData/xml/WrongRegExpCategory.xsd +++ b/xml/tests/testData/xml/WrongRegExpCategory.xsd @@ -2,7 +2,9 @@ - + IsUnknown}]*"/> + + IsCc}+"/> diff --git a/xml/xml-psi-impl/src/com/intellij/psi/impl/source/xml/XmlAttributeValueImpl.java b/xml/xml-psi-impl/src/com/intellij/psi/impl/source/xml/XmlAttributeValueImpl.java index 6f9c6fba04c8..71a18ab3f605 100644 --- a/xml/xml-psi-impl/src/com/intellij/psi/impl/source/xml/XmlAttributeValueImpl.java +++ b/xml/xml-psi-impl/src/com/intellij/psi/impl/source/xml/XmlAttributeValueImpl.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -245,11 +245,8 @@ public class XmlAttributeValueImpl extends XmlElementImpl implements XmlAttribut try { return Character.UnicodeBlock.forName(category.substring(2)) != null; } - catch (IllegalArgumentException e) { - return false; - } + catch (IllegalArgumentException ignore) {} } - category = StringUtil.trimStart(category, "Is"); for (String[] name : DefaultRegExpPropertiesProvider.getInstance().getAllKnownProperties()) { if (name[0].equals(category)) { return true;