diff options
Diffstat (limited to '2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0')
4 files changed, 1701 insertions, 0 deletions
diff --git a/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/index.html b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/index.html new file mode 100644 index 0000000..e424628 --- /dev/null +++ b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/index.html @@ -0,0 +1,94 @@ +<html> +<head> +<title>rootdir - scan-build results</title> +<link type="text/css" rel="stylesheet" href="scanview.css"/> +<script src="sorttable.js"></script> +<script language='javascript' type="text/javascript"> +function SetDisplay(RowClass, DisplayVal) +{ + var Rows = document.getElementsByTagName("tr"); + for ( var i = 0 ; i < Rows.length; ++i ) { + if (Rows[i].className == RowClass) { + Rows[i].style.display = DisplayVal; + } + } +} + +function CopyCheckedStateToCheckButtons(SummaryCheckButton) { + var Inputs = document.getElementsByTagName("input"); + for ( var i = 0 ; i < Inputs.length; ++i ) { + if (Inputs[i].type == "checkbox") { + if(Inputs[i] != SummaryCheckButton) { + Inputs[i].checked = SummaryCheckButton.checked; + Inputs[i].onclick(); + } + } + } +} + +function returnObjById( id ) { + if (document.getElementById) + var returnVar = document.getElementById(id); + else if (document.all) + var returnVar = document.all[id]; + else if (document.layers) + var returnVar = document.layers[id]; + return returnVar; +} + +var NumUnchecked = 0; + +function ToggleDisplay(CheckButton, ClassName) { + if (CheckButton.checked) { + SetDisplay(ClassName, ""); + if (--NumUnchecked == 0) { + returnObjById("AllBugsCheck").checked = true; + } + } + else { + SetDisplay(ClassName, "none"); + NumUnchecked++; + returnObjById("AllBugsCheck").checked = false; + } +} +</script> +<!-- SUMMARYENDHEAD --> +</head> +<body> +<h1>rootdir - scan-build results</h1> + +<table> +<tr><th>User:</th><td>root@642756c4ec8f</td></tr> +<tr><th>Working Directory:</th><td>/rootdir</td></tr> +<tr><th>Command Line:</th><td>make -j 2</td></tr> +<tr><th>Clang Version:</th><td>clang version 14.0.5 (Fedora 14.0.5-1.fc36) +</td></tr> +<tr><th>Date:</th><td>Fri Nov 11 20:18:52 2022</td></tr> +</table> +<h2>Bug Summary</h2><table> +<thead><tr><td>Bug Type</td><td>Quantity</td><td class="sorttable_nosort">Display?</td></tr></thead> +<tr style="font-weight:bold"><td class="SUMM_DESC">All Bugs</td><td class="Q">1</td><td><center><input type="checkbox" id="AllBugsCheck" onClick="CopyCheckedStateToCheckButtons(this);" checked/></center></td></tr> +<tr><th>Logic error</th><th colspan=2></th></tr> +<tr><td class="SUMM_DESC">Potential unintended use of sizeof() on pointer type</td><td class="Q">1</td><td><center><input type="checkbox" onClick="ToggleDisplay(this,'bt_logic_error_potential_unintended_use_of_sizeof_on_pointer_type');" checked/></center></td></tr> +</table> +<h2>Reports</h2> + +<table class="sortable" style="table-layout:automatic"> +<thead><tr> + <td>Bug Group</td> + <td class="sorttable_sorted">Bug Type<span id="sorttable_sortfwdind"> ▾</span></td> + <td>File</td> + <td>Function/Method</td> + <td class="Q">Line</td> + <td class="Q">Path Length</td> + <td class="sorttable_nosort"></td> + <!-- REPORTBUGCOL --> +</tr></thead> +<tbody> +<tr class="bt_logic_error_potential_unintended_use_of_sizeof_on_pointer_type"><td class="DESC">Logic error</td><td class="DESC">Potential unintended use of sizeof() on pointer type</td><td>abstract.h</td><td class="DESC">PyVectorcall_Function</td><td class="Q">76</td><td class="Q">1</td><td><a href="report-edc6e6.html#EndPath">View Report</a></td> +<!-- REPORTBUG id="report-edc6e6.html" --> +</tr> +</tbody> +</table> + +</body></html> diff --git a/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/report-edc6e6.html b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/report-edc6e6.html new file mode 100644 index 0000000..1243124 --- /dev/null +++ b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/report-edc6e6.html @@ -0,0 +1,1053 @@ +<!doctype html> +<html> +<head> +<title>/usr/include/python3.10/cpython/abstract.h</title> + +<style type="text/css"> +body { color:#000000; background-color:#ffffff } +body { font-family:Helvetica, sans-serif; font-size:10pt } +h1 { font-size:14pt } +.FileName { margin-top: 5px; margin-bottom: 5px; display: inline; } +.FileNav { margin-left: 5px; margin-right: 5px; display: inline; } +.FileNav a { text-decoration:none; font-size: larger; } +.divider { margin-top: 30px; margin-bottom: 30px; height: 15px; } +.divider { background-color: gray; } +.code { border-collapse:collapse; width:100%; } +.code { font-family: "Monospace", monospace; font-size:10pt } +.code { line-height: 1.2em } +.comment { color: green; font-style: oblique } +.keyword { color: blue } +.string_literal { color: red } +.directive { color: darkmagenta } + +/* Macros and variables could have pop-up notes hidden by default. + - Macro pop-up: expansion of the macro + - Variable pop-up: value (table) of the variable */ +.macro_popup, .variable_popup { display: none; } + +/* Pop-up appears on mouse-hover event. */ +.macro:hover .macro_popup, .variable:hover .variable_popup { + display: block; + padding: 2px; + -webkit-border-radius:5px; + -webkit-box-shadow:1px 1px 7px #000; + border-radius:5px; + box-shadow:1px 1px 7px #000; + position: absolute; + top: -1em; + left:10em; + z-index: 1 +} + +.macro_popup { + border: 2px solid red; + background-color:#FFF0F0; + font-weight: normal; +} + +.variable_popup { + border: 2px solid blue; + background-color:#F0F0FF; + font-weight: bold; + font-family: Helvetica, sans-serif; + font-size: 9pt; +} + +/* Pop-up notes needs a relative position as a base where they pops up. */ +.macro, .variable { + background-color: PaleGoldenRod; + position: relative; +} +.macro { color: DarkMagenta; } + +#tooltiphint { + position: fixed; + width: 50em; + margin-left: -25em; + left: 50%; + padding: 10px; + border: 1px solid #b0b0b0; + border-radius: 2px; + box-shadow: 1px 1px 7px black; + background-color: #c0c0c0; + z-index: 2; +} + +.num { width:2.5em; padding-right:2ex; background-color:#eeeeee } +.num { text-align:right; font-size:8pt } +.num { color:#444444 } +.line { padding-left: 1ex; border-left: 3px solid #ccc } +.line { white-space: pre } +.msg { -webkit-box-shadow:1px 1px 7px #000 } +.msg { box-shadow:1px 1px 7px #000 } +.msg { -webkit-border-radius:5px } +.msg { border-radius:5px } +.msg { font-family:Helvetica, sans-serif; font-size:8pt } +.msg { float:left } +.msg { position:relative } +.msg { padding:0.25em 1ex 0.25em 1ex } +.msg { margin-top:10px; margin-bottom:10px } +.msg { font-weight:bold } +.msg { max-width:60em; word-wrap: break-word; white-space: pre-wrap } +.msgT { padding:0x; spacing:0x } +.msgEvent { background-color:#fff8b4; color:#000000 } +.msgControl { background-color:#bbbbbb; color:#000000 } +.msgNote { background-color:#ddeeff; color:#000000 } +.mrange { background-color:#dfddf3 } +.mrange { border-bottom:1px solid #6F9DBE } +.PathIndex { font-weight: bold; padding:0px 5px; margin-right:5px; } +.PathIndex { -webkit-border-radius:8px } +.PathIndex { border-radius:8px } +.PathIndexEvent { background-color:#bfba87 } +.PathIndexControl { background-color:#8c8c8c } +.PathIndexPopUp { background-color: #879abc; } +.PathNav a { text-decoration:none; font-size: larger } +.CodeInsertionHint { font-weight: bold; background-color: #10dd10 } +.CodeRemovalHint { background-color:#de1010 } +.CodeRemovalHint { border-bottom:1px solid #6F9DBE } +.msg.selected{ background-color:orange !important; } + +table.simpletable { + padding: 5px; + font-size:12pt; + margin:20px; + border-collapse: collapse; border-spacing: 0px; +} +td.rowname { + text-align: right; + vertical-align: top; + font-weight: bold; + color:#444444; + padding-right:2ex; +} + +/* Hidden text. */ +input.spoilerhider + label { + cursor: pointer; + text-decoration: underline; + display: block; +} +input.spoilerhider { + display: none; +} +input.spoilerhider ~ .spoiler { + overflow: hidden; + margin: 10px auto 0; + height: 0; + opacity: 0; +} +input.spoilerhider:checked + label + .spoiler{ + height: auto; + opacity: 1; +} +</style> +</head> +<body> +<!-- BUGDESC The code calls sizeof() on a pointer type. This can produce an unexpected result --> + +<!-- BUGTYPE Potential unintended use of sizeof() on pointer type --> + +<!-- BUGCATEGORY Logic error --> + +<!-- BUGFILE /usr/include/python3.10/cpython/abstract.h --> + +<!-- FILENAME abstract.h --> + +<!-- FUNCTIONNAME PyVectorcall_Function --> + +<!-- ISSUEHASHCONTENTOFLINEINCONTEXT edc6e636b990c4f03b93f49dee9a7cbc --> + +<!-- BUGLINE 76 --> + +<!-- BUGCOLUMN 46 --> + +<!-- BUGPATHLENGTH 1 --> + +<!-- BUGMETAEND --> +<!-- REPORTHEADER --> +<h3>Bug Summary</h3> +<table class="simpletable"> +<tr><td class="rowname">File:</td><td>abstract.h</td></tr> +<tr><td class="rowname">Warning:</td><td><a href="#EndPath">line 76, column 46</a><br />The code calls sizeof() on a pointer type. This can produce an unexpected result</td></tr> + +</table> +<!-- REPORTSUMMARYEXTRA --> +<h3>Annotated Source Code</h3> +<p>Press <a href="#" onclick="toggleHelp(); return false;">'?'</a> + to see keyboard shortcuts</p> +<input type="checkbox" class="spoilerhider" id="showinvocation" /> +<label for="showinvocation" >Show analyzer invocation</label> +<div class="spoiler">clang -cc1 -cc1 -triple x86_64-redhat-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name caja-python-object.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib64/clang/14.0.5 -D HAVE_CONFIG_H -I . -I .. -I .. -I .. -D G_LOG_DOMAIN="Caja-Python" -D DATADIR="/usr/local/share" -D LIBDIR="/usr/local/lib" -D PYTHON_VERSION="3.10" -D PYTHON_ABIFLAGS="" -D PY_LIB_LOC="/usr/lib64" -I /usr/include/python3.10 -I /usr/include/pygobject-3.0 -I /usr/include/glib-2.0 -I /usr/lib64/glib-2.0/include -I /usr/include/sysprof-4 -I /usr/include/caja -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/gtk-3.0 -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/fribidi -I /usr/include/libxml2 -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/gio-unix-2.0 -I /usr/include/cloudproviders -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/dbus-1.0 -I /usr/lib64/dbus-1.0/include -I /usr/include/at-spi-2.0 -D PIC -internal-isystem /usr/lib64/clang/14.0.5/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/12/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -fdebug-compilation-dir=/rootdir/src -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-checker security.insecureAPI.strcpy -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2022-11-11-201852-5591-1 -x c caja-python-object.c +</div> +<div id='tooltiphint' hidden="true"> + <p>Keyboard shortcuts: </p> + <ul> + <li>Use 'j/k' keys for keyboard navigation</li> + <li>Use 'Shift+S' to show/hide relevant lines</li> + <li>Use '?' to toggle this window</li> + </ul> + <a href="#" onclick="toggleHelp(); return false;">Close</a> +</div> +<script type='text/javascript'> +var relevant_lines = {"47523": {"76": 1}}; + +var filterCounterexample = function (hide) { + var tables = document.getElementsByClassName("code"); + for (var t=0; t<tables.length; t++) { + var table = tables[t]; + var file_id = table.getAttribute("data-fileid"); + var lines_in_fid = relevant_lines[file_id]; + if (!lines_in_fid) { + lines_in_fid = {}; + } + var lines = table.getElementsByClassName("codeline"); + for (var i=0; i<lines.length; i++) { + var el = lines[i]; + var lineNo = el.getAttribute("data-linenumber"); + if (!lines_in_fid[lineNo]) { + if (hide) { + el.setAttribute("hidden", ""); + } else { + el.removeAttribute("hidden"); + } + } + } + } +} + +window.addEventListener("keydown", function (event) { + if (event.defaultPrevented) { + return; + } + // SHIFT + S + if (event.shiftKey && event.keyCode == 83) { + var checked = document.getElementsByName("showCounterexample")[0].checked; + filterCounterexample(!checked); + document.getElementsByName("showCounterexample")[0].click(); + } else { + return; + } + event.preventDefault(); +}, true); + +document.addEventListener("DOMContentLoaded", function() { + document.querySelector('input[name="showCounterexample"]').onchange= + function (event) { + filterCounterexample(this.checked); + }; +}); +</script> + +<form> + <input type="checkbox" name="showCounterexample" id="showCounterexample" /> + <label for="showCounterexample"> + Show only relevant lines + </label> + <input type="checkbox" name="showArrows" + id="showArrows" style="margin-left: 10px" /> + <label for="showArrows"> + Show control flow arrows + </label> +</form> + +<script type='text/javascript'> +// Return range of numbers from a range [lower, upper). +function range(lower, upper) { + var array = []; + for (var i = lower; i <= upper; ++i) { + array.push(i); + } + return array; +} + +var getRelatedArrowIndices = function(pathId) { + // HTML numeration of events is a bit different than it is in the path. + // Everything is rotated one step to the right, so the last element + // (error diagnostic) has index 0. + if (pathId == 0) { + // arrowIndices has at least 2 elements + pathId = arrowIndices.length - 1; + } + + return range(arrowIndices[pathId], arrowIndices[pathId - 1]); +} + +var highlightArrowsForSelectedEvent = function() { + const selectedNum = findNum(); + const arrowIndicesToHighlight = getRelatedArrowIndices(selectedNum); + arrowIndicesToHighlight.forEach((index) => { + var arrow = document.querySelector("#arrow" + index); + if(arrow) { + classListAdd(arrow, "selected") + } + }); +} + +var getAbsoluteBoundingRect = function(element) { + const relative = element.getBoundingClientRect(); + return { + left: relative.left + window.pageXOffset, + right: relative.right + window.pageXOffset, + top: relative.top + window.pageYOffset, + bottom: relative.bottom + window.pageYOffset, + height: relative.height, + width: relative.width + }; +} + +var drawArrow = function(index) { + // This function is based on the great answer from SO: + // https://stackoverflow.com/a/39575674/11582326 + var start = document.querySelector("#start" + index); + var end = document.querySelector("#end" + index); + var arrow = document.querySelector("#arrow" + index); + + var startRect = getAbsoluteBoundingRect(start); + var endRect = getAbsoluteBoundingRect(end); + + // It is an arrow from a token to itself, no need to visualize it. + if (startRect.top == endRect.top && + startRect.left == endRect.left) + return; + + // Each arrow is a very simple Bézier curve, with two nodes and + // two handles. So, we need to calculate four points in the window: + // * start node + var posStart = { x: 0, y: 0 }; + // * end node + var posEnd = { x: 0, y: 0 }; + // * handle for the start node + var startHandle = { x: 0, y: 0 }; + // * handle for the end node + var endHandle = { x: 0, y: 0 }; + // One can visualize it as follows: + // + // start handle + // / + // X"""_.-""""X + // .' \ + // / start node + // | + // | + // | end node + // \ / + // `->X + // X-' + // \ + // end handle + // + // NOTE: (0, 0) is the top left corner of the window. + + // We have 3 similar, but still different scenarios to cover: + // + // 1. Two tokens on different lines. + // -xxx + // / + // \ + // -> xxx + // In this situation, we draw arrow on the left curving to the left. + // 2. Two tokens on the same line, and the destination is on the right. + // ____ + // / \ + // / V + // xxx xxx + // In this situation, we draw arrow above curving upwards. + // 3. Two tokens on the same line, and the destination is on the left. + // xxx xxx + // ^ / + // \____/ + // In this situation, we draw arrow below curving downwards. + const onDifferentLines = startRect.top <= endRect.top - 5 || + startRect.top >= endRect.top + 5; + const leftToRight = startRect.left < endRect.left; + + // NOTE: various magic constants are chosen empirically for + // better positioning and look + if (onDifferentLines) { + // Case #1 + const topToBottom = startRect.top < endRect.top; + posStart.x = startRect.left - 1; + // We don't want to start it at the top left corner of the token, + // it doesn't feel like this is where the arrow comes from. + // For this reason, we start it in the middle of the left side + // of the token. + posStart.y = startRect.top + startRect.height / 2; + + // End node has arrow head and we give it a bit more space. + posEnd.x = endRect.left - 4; + posEnd.y = endRect.top; + + // Utility object with x and y offsets for handles. + var curvature = { + // We want bottom-to-top arrow to curve a bit more, so it doesn't + // overlap much with top-to-bottom curves (much more frequent). + x: topToBottom ? 15 : 25, + y: Math.min((posEnd.y - posStart.y) / 3, 10) + } + + // When destination is on the different line, we can make a + // curvier arrow because we have space for it. + // So, instead of using + // + // startHandle.x = posStart.x - curvature.x + // endHandle.x = posEnd.x - curvature.x + // + // We use the leftmost of these two values for both handles. + startHandle.x = Math.min(posStart.x, posEnd.x) - curvature.x; + endHandle.x = startHandle.x; + + // Curving downwards from the start node... + startHandle.y = posStart.y + curvature.y; + // ... and upwards from the end node. + endHandle.y = posEnd.y - curvature.y; + + } else if (leftToRight) { + // Case #2 + // Starting from the top right corner... + posStart.x = startRect.right - 1; + posStart.y = startRect.top; + + // ...and ending at the top left corner of the end token. + posEnd.x = endRect.left + 1; + posEnd.y = endRect.top - 1; + + // Utility object with x and y offsets for handles. + var curvature = { + x: Math.min((posEnd.x - posStart.x) / 3, 15), + y: 5 + } + + // Curving to the right... + startHandle.x = posStart.x + curvature.x; + // ... and upwards from the start node. + startHandle.y = posStart.y - curvature.y; + + // And to the left... + endHandle.x = posEnd.x - curvature.x; + // ... and upwards from the end node. + endHandle.y = posEnd.y - curvature.y; + + } else { + // Case #3 + // Starting from the bottom right corner... + posStart.x = startRect.right; + posStart.y = startRect.bottom; + + // ...and ending also at the bottom right corner, but of the end token. + posEnd.x = endRect.right - 1; + posEnd.y = endRect.bottom + 1; + + // Utility object with x and y offsets for handles. + var curvature = { + x: Math.min((posStart.x - posEnd.x) / 3, 15), + y: 5 + } + + // Curving to the left... + startHandle.x = posStart.x - curvature.x; + // ... and downwards from the start node. + startHandle.y = posStart.y + curvature.y; + + // And to the right... + endHandle.x = posEnd.x + curvature.x; + // ... and downwards from the end node. + endHandle.y = posEnd.y + curvature.y; + } + + // Put it all together into a path. + // More information on the format: + // https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths + var pathStr = "M" + posStart.x + "," + posStart.y + " " + + "C" + startHandle.x + "," + startHandle.y + " " + + endHandle.x + "," + endHandle.y + " " + + posEnd.x + "," + posEnd.y; + + arrow.setAttribute("d", pathStr); +}; + +var drawArrows = function() { + const numOfArrows = document.querySelectorAll("path[id^=arrow]").length; + for (var i = 0; i < numOfArrows; ++i) { + drawArrow(i); + } +} + +var toggleArrows = function(event) { + const arrows = document.querySelector("#arrows"); + if (event.target.checked) { + arrows.setAttribute("visibility", "visible"); + } else { + arrows.setAttribute("visibility", "hidden"); + } +} + +window.addEventListener("resize", drawArrows); +document.addEventListener("DOMContentLoaded", function() { + // Whenever we show invocation, locations change, i.e. we + // need to redraw arrows. + document + .querySelector('input[id="showinvocation"]') + .addEventListener("click", drawArrows); + // Hiding irrelevant lines also should cause arrow rerender. + document + .querySelector('input[name="showCounterexample"]') + .addEventListener("change", drawArrows); + document + .querySelector('input[name="showArrows"]') + .addEventListener("change", toggleArrows); + drawArrows(); + // Default highlighting for the last event. + highlightArrowsForSelectedEvent(); +}); +</script> + +<script type='text/javascript'> +var digitMatcher = new RegExp("[0-9]+"); + +var querySelectorAllArray = function(selector) { + return Array.prototype.slice.call( + document.querySelectorAll(selector)); +} + +document.addEventListener("DOMContentLoaded", function() { + querySelectorAllArray(".PathNav > a").forEach( + function(currentValue, currentIndex) { + var hrefValue = currentValue.getAttribute("href"); + currentValue.onclick = function() { + scrollTo(document.querySelector(hrefValue)); + return false; + }; + }); +}); + +var findNum = function() { + var s = document.querySelector(".msg.selected"); + if (!s || s.id == "EndPath") { + return 0; + } + var out = parseInt(digitMatcher.exec(s.id)[0]); + return out; +}; + +var classListAdd = function(el, theClass) { + if(!el.className.baseVal) + el.className += " " + theClass; + else + el.className.baseVal += " " + theClass; +}; + +var classListRemove = function(el, theClass) { + var className = (!el.className.baseVal) ? + el.className : el.className.baseVal; + className = className.replace(" " + theClass, ""); + if(!el.className.baseVal) + el.className = className; + else + el.className.baseVal = className; +}; + +var scrollTo = function(el) { + querySelectorAllArray(".selected").forEach(function(s) { + classListRemove(s, "selected"); + }); + classListAdd(el, "selected"); + window.scrollBy(0, el.getBoundingClientRect().top - + (window.innerHeight / 2)); + highlightArrowsForSelectedEvent(); +}; + +var move = function(num, up, numItems) { + if (num == 1 && up || num == numItems - 1 && !up) { + return 0; + } else if (num == 0 && up) { + return numItems - 1; + } else if (num == 0 && !up) { + return 1 % numItems; + } + return up ? num - 1 : num + 1; +} + +var numToId = function(num) { + if (num == 0) { + return document.getElementById("EndPath") + } + return document.getElementById("Path" + num); +}; + +var navigateTo = function(up) { + var numItems = document.querySelectorAll( + ".line > .msgEvent, .line > .msgControl").length; + var currentSelected = findNum(); + var newSelected = move(currentSelected, up, numItems); + var newEl = numToId(newSelected, numItems); + + // Scroll element into center. + scrollTo(newEl); +}; + +window.addEventListener("keydown", function (event) { + if (event.defaultPrevented) { + return; + } + // key 'j' + if (event.keyCode == 74) { + navigateTo(/*up=*/false); + // key 'k' + } else if (event.keyCode == 75) { + navigateTo(/*up=*/true); + } else { + return; + } + event.preventDefault(); +}, true); +</script> + +<script type='text/javascript'> + +var toggleHelp = function() { + var hint = document.querySelector("#tooltiphint"); + var attributeName = "hidden"; + if (hint.hasAttribute(attributeName)) { + hint.removeAttribute(attributeName); + } else { + hint.setAttribute("hidden", "true"); + } +}; +window.addEventListener("keydown", function (event) { + if (event.defaultPrevented) { + return; + } + if (event.key == "?") { + toggleHelp(); + } else { + return; + } + event.preventDefault(); +}); +</script> + +<style type="text/css"> + svg { + position:absolute; + top:0; + left:0; + height:100%; + width:100%; + pointer-events: none; + overflow: visible + } + .arrow { + stroke-opacity: 0.2; + stroke-width: 1; + marker-end: url(#arrowhead); + } + + .arrow.selected { + stroke-opacity: 0.6; + stroke-width: 2; + marker-end: url(#arrowheadSelected); + } + + .arrowhead { + orient: auto; + stroke: none; + opacity: 0.6; + fill: blue; + } +</style> +<svg xmlns="http://www.w3.org/2000/svg"> + <defs> + <marker id="arrowheadSelected" class="arrowhead" opacity="0.6" + viewBox="0 0 10 10" refX="3" refY="5" + markerWidth="4" markerHeight="4"> + <path d="M 0 0 L 10 5 L 0 10 z" /> + </marker> + <marker id="arrowhead" class="arrowhead" opacity="0.2" + viewBox="0 0 10 10" refX="3" refY="5" + markerWidth="4" markerHeight="4"> + <path d="M 0 0 L 10 5 L 0 10 z" /> + </marker> + </defs> + <g id="arrows" fill="none" stroke="blue" visibility="hidden"> + + </g> +</svg> +<script type='text/javascript'> +const arrowIndices = [ 0,0 ] +</script> +<table class="code" data-fileid="47523"> +<tr class="codeline" data-linenumber="1"><td class="num" id="LN1">1</td><td class="line"><span class='directive'>#ifndef Py_CPYTHON_ABSTRACTOBJECT_H</span></td></tr> +<tr class="codeline" data-linenumber="2"><td class="num" id="LN2">2</td><td class="line"><span class='directive'># error "this header file must not be included directly"</span></td></tr> +<tr class="codeline" data-linenumber="3"><td class="num" id="LN3">3</td><td class="line"><span class='directive'>#endif</span></td></tr> +<tr class="codeline" data-linenumber="4"><td class="num" id="LN4">4</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="5"><td class="num" id="LN5">5</td><td class="line"><span class='comment'>/* === Object Protocol ================================================== */</span></td></tr> +<tr class="codeline" data-linenumber="6"><td class="num" id="LN6">6</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="7"><td class="num" id="LN7">7</td><td class="line"><span class='directive'>#ifdef PY_SSIZE_T_CLEAN</span></td></tr> +<tr class="codeline" data-linenumber="8"><td class="num" id="LN8">8</td><td class="line"><span class='directive'># define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT</span></td></tr> +<tr class="codeline" data-linenumber="9"><td class="num" id="LN9">9</td><td class="line"><span class='directive'>#endif</span></td></tr> +<tr class="codeline" data-linenumber="10"><td class="num" id="LN10">10</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="11"><td class="num" id="LN11">11</td><td class="line"><span class='comment'>/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple)</span></td></tr> +<tr class="codeline" data-linenumber="12"><td class="num" id="LN12">12</td><td class="line"> <span class='comment'>format to a Python dictionary ("kwargs" dict).</span></td></tr> +<tr class="codeline" data-linenumber="13"><td class="num" id="LN13">13</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="14"><td class="num" id="LN14">14</td><td class="line"> <span class='comment'>The type of kwnames keys is not checked. The final function getting</span></td></tr> +<tr class="codeline" data-linenumber="15"><td class="num" id="LN15">15</td><td class="line"> <span class='comment'>arguments is responsible to check if all keys are strings, for example using</span></td></tr> +<tr class="codeline" data-linenumber="16"><td class="num" id="LN16">16</td><td class="line"> <span class='comment'>PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments().</span></td></tr> +<tr class="codeline" data-linenumber="17"><td class="num" id="LN17">17</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="18"><td class="num" id="LN18">18</td><td class="line"> <span class='comment'>Duplicate keys are merged using the last value. If duplicate keys must raise</span></td></tr> +<tr class="codeline" data-linenumber="19"><td class="num" id="LN19">19</td><td class="line"> <span class='comment'>an exception, the caller is responsible to implement an explicit keys on</span></td></tr> +<tr class="codeline" data-linenumber="20"><td class="num" id="LN20">20</td><td class="line"> <span class='comment'>kwnames. */</span></td></tr> +<tr class="codeline" data-linenumber="21"><td class="num" id="LN21">21</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyStack_AsDict(</td></tr> +<tr class="codeline" data-linenumber="22"><td class="num" id="LN22">22</td><td class="line"> PyObject *<span class='keyword'>const</span> *values,</td></tr> +<tr class="codeline" data-linenumber="23"><td class="num" id="LN23">23</td><td class="line"> PyObject *kwnames);</td></tr> +<tr class="codeline" data-linenumber="24"><td class="num" id="LN24">24</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="25"><td class="num" id="LN25">25</td><td class="line"><span class='comment'>/* Suggested size (number of positional arguments) for arrays of PyObject*</span></td></tr> +<tr class="codeline" data-linenumber="26"><td class="num" id="LN26">26</td><td class="line"> <span class='comment'>allocated on a C stack to avoid allocating memory on the heap memory. Such</span></td></tr> +<tr class="codeline" data-linenumber="27"><td class="num" id="LN27">27</td><td class="line"> <span class='comment'>array is used to pass positional arguments to call functions of the</span></td></tr> +<tr class="codeline" data-linenumber="28"><td class="num" id="LN28">28</td><td class="line"> <span class='comment'>PyObject_Vectorcall() family.</span></td></tr> +<tr class="codeline" data-linenumber="29"><td class="num" id="LN29">29</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="30"><td class="num" id="LN30">30</td><td class="line"> <span class='comment'>The size is chosen to not abuse the C stack and so limit the risk of stack</span></td></tr> +<tr class="codeline" data-linenumber="31"><td class="num" id="LN31">31</td><td class="line"> <span class='comment'>overflow. The size is also chosen to allow using the small stack for most</span></td></tr> +<tr class="codeline" data-linenumber="32"><td class="num" id="LN32">32</td><td class="line"> <span class='comment'>function calls of the Python standard library. On 64-bit CPU, it allocates</span></td></tr> +<tr class="codeline" data-linenumber="33"><td class="num" id="LN33">33</td><td class="line"> <span class='comment'>40 bytes on the stack. */</span></td></tr> +<tr class="codeline" data-linenumber="34"><td class="num" id="LN34">34</td><td class="line"><span class='directive'>#define <span class='macro'>_PY_FASTCALL_SMALL_STACK<span class='macro_popup'>5</span></span> 5</span></td></tr> +<tr class="codeline" data-linenumber="35"><td class="num" id="LN35">35</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="36"><td class="num" id="LN36">36</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _Py_CheckFunctionResult(</td></tr> +<tr class="codeline" data-linenumber="37"><td class="num" id="LN37">37</td><td class="line"> PyThreadState *tstate,</td></tr> +<tr class="codeline" data-linenumber="38"><td class="num" id="LN38">38</td><td class="line"> PyObject *callable,</td></tr> +<tr class="codeline" data-linenumber="39"><td class="num" id="LN39">39</td><td class="line"> PyObject *result,</td></tr> +<tr class="codeline" data-linenumber="40"><td class="num" id="LN40">40</td><td class="line"> <span class='keyword'>const</span> <span class='keyword'>char</span> *where);</td></tr> +<tr class="codeline" data-linenumber="41"><td class="num" id="LN41">41</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="42"><td class="num" id="LN42">42</td><td class="line"><span class='comment'>/* === Vectorcall protocol (PEP 590) ============================= */</span></td></tr> +<tr class="codeline" data-linenumber="43"><td class="num" id="LN43">43</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="44"><td class="num" id="LN44">44</td><td class="line"><span class='comment'>/* Call callable using tp_call. Arguments are like PyObject_Vectorcall()</span></td></tr> +<tr class="codeline" data-linenumber="45"><td class="num" id="LN45">45</td><td class="line"> <span class='comment'>or PyObject_FastCallDict() (both forms are supported),</span></td></tr> +<tr class="codeline" data-linenumber="46"><td class="num" id="LN46">46</td><td class="line"> <span class='comment'>except that nargs is plainly the number of arguments without flags. */</span></td></tr> +<tr class="codeline" data-linenumber="47"><td class="num" id="LN47">47</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyObject_MakeTpCall(</td></tr> +<tr class="codeline" data-linenumber="48"><td class="num" id="LN48">48</td><td class="line"> PyThreadState *tstate,</td></tr> +<tr class="codeline" data-linenumber="49"><td class="num" id="LN49">49</td><td class="line"> PyObject *callable,</td></tr> +<tr class="codeline" data-linenumber="50"><td class="num" id="LN50">50</td><td class="line"> PyObject *<span class='keyword'>const</span> *args, Py_ssize_t nargs,</td></tr> +<tr class="codeline" data-linenumber="51"><td class="num" id="LN51">51</td><td class="line"> PyObject *keywords);</td></tr> +<tr class="codeline" data-linenumber="52"><td class="num" id="LN52">52</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="53"><td class="num" id="LN53">53</td><td class="line"><span class='directive'>#define <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span> ((size_t)1 << (8 * sizeof(size_t) - 1))</span></td></tr> +<tr class="codeline" data-linenumber="54"><td class="num" id="LN54">54</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="55"><td class="num" id="LN55">55</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> Py_ssize_t</td></tr> +<tr class="codeline" data-linenumber="56"><td class="num" id="LN56">56</td><td class="line">PyVectorcall_NARGS(size_t n)</td></tr> +<tr class="codeline" data-linenumber="57"><td class="num" id="LN57">57</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="58"><td class="num" id="LN58">58</td><td class="line"> <span class='keyword'>return</span> n & ~<span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="59"><td class="num" id="LN59">59</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="60"><td class="num" id="LN60">60</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="61"><td class="num" id="LN61">61</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> vectorcallfunc</td></tr> +<tr class="codeline" data-linenumber="62"><td class="num" id="LN62">62</td><td class="line">PyVectorcall_Function(PyObject *callable)</td></tr> +<tr class="codeline" data-linenumber="63"><td class="num" id="LN63">63</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="64"><td class="num" id="LN64">64</td><td class="line"> PyTypeObject *tp;</td></tr> +<tr class="codeline" data-linenumber="65"><td class="num" id="LN65">65</td><td class="line"> Py_ssize_t offset;</td></tr> +<tr class="codeline" data-linenumber="66"><td class="num" id="LN66">66</td><td class="line"> vectorcallfunc ptr;</td></tr> +<tr class="codeline" data-linenumber="67"><td class="num" id="LN67">67</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="68"><td class="num" id="LN68">68</td><td class="line"> <span class='macro'>assert(callable != NULL)<span class='macro_popup'>((void) sizeof ((callable != ((void*)0)) ? 1 : 0), __extension__<br> ({ if (callable != ((void*)0)) ; else __assert_fail ("callable != NULL"<br>, "/usr/include/python3.10/cpython/abstract.h", 68, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="69"><td class="num" id="LN69">69</td><td class="line"> tp = <span class='macro'>Py_TYPE(callable)<span class='macro_popup'>(((PyObject*)(callable))->ob_type)</span></span>;</td></tr> +<tr class="codeline" data-linenumber="70"><td class="num" id="LN70">70</td><td class="line"> <span class='keyword'>if</span> (!PyType_HasFeature(tp, <span class='macro'>Py_TPFLAGS_HAVE_VECTORCALL<span class='macro_popup'>(1UL << 11)</span></span>)) {</td></tr> +<tr class="codeline" data-linenumber="71"><td class="num" id="LN71">71</td><td class="line"> <span class='keyword'>return</span> <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>;</td></tr> +<tr class="codeline" data-linenumber="72"><td class="num" id="LN72">72</td><td class="line"> }</td></tr> +<tr class="codeline" data-linenumber="73"><td class="num" id="LN73">73</td><td class="line"> <span class='macro'>assert(PyCallable_Check(callable))<span class='macro_popup'>((void) sizeof ((PyCallable_Check(callable)) ? 1 : 0), __extension__<br> ({ if (PyCallable_Check(callable)) ; else __assert_fail ("PyCallable_Check(callable)"<br>, "/usr/include/python3.10/cpython/abstract.h", 73, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="74"><td class="num" id="LN74">74</td><td class="line"> offset = tp->tp_vectorcall_offset;</td></tr> +<tr class="codeline" data-linenumber="75"><td class="num" id="LN75">75</td><td class="line"> <span class='macro'>assert(offset > 0)<span class='macro_popup'>((void) sizeof ((offset > 0) ? 1 : 0), __extension__ ({ if<br> (offset > 0) ; else __assert_fail ("offset > 0", "/usr/include/python3.10/cpython/abstract.h"<br>, 75, __extension__ __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="76"><td class="num" id="LN76">76</td><td class="line"> memcpy(&ptr, (<span class='keyword'>char</span> *) callable + offset, <span class='keyword'>sizeof</span><span class="mrange">(ptr)</span>);</td></tr> +<tr><td class="num"></td><td class="line"><div id="EndPath" class="msg msgEvent" style="margin-left:46ex">The code calls sizeof() on a pointer type. This can produce an unexpected result</div></td></tr> +<tr class="codeline" data-linenumber="77"><td class="num" id="LN77">77</td><td class="line"> <span class='keyword'>return</span> ptr;</td></tr> +<tr class="codeline" data-linenumber="78"><td class="num" id="LN78">78</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="79"><td class="num" id="LN79">79</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="80"><td class="num" id="LN80">80</td><td class="line"><span class='comment'>/* Call the callable object 'callable' with the "vectorcall" calling</span></td></tr> +<tr class="codeline" data-linenumber="81"><td class="num" id="LN81">81</td><td class="line"> <span class='comment'>convention.</span></td></tr> +<tr class="codeline" data-linenumber="82"><td class="num" id="LN82">82</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="83"><td class="num" id="LN83">83</td><td class="line"> <span class='comment'>args is a C array for positional arguments.</span></td></tr> +<tr class="codeline" data-linenumber="84"><td class="num" id="LN84">84</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="85"><td class="num" id="LN85">85</td><td class="line"> <span class='comment'>nargsf is the number of positional arguments plus optionally the flag</span></td></tr> +<tr class="codeline" data-linenumber="86"><td class="num" id="LN86">86</td><td class="line"> <span class='comment'>PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to</span></td></tr> +<tr class="codeline" data-linenumber="87"><td class="num" id="LN87">87</td><td class="line"> <span class='comment'>modify args[-1].</span></td></tr> +<tr class="codeline" data-linenumber="88"><td class="num" id="LN88">88</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="89"><td class="num" id="LN89">89</td><td class="line"> <span class='comment'>kwnames is a tuple of keyword names. The values of the keyword arguments</span></td></tr> +<tr class="codeline" data-linenumber="90"><td class="num" id="LN90">90</td><td class="line"> <span class='comment'>are stored in "args" after the positional arguments (note that the number</span></td></tr> +<tr class="codeline" data-linenumber="91"><td class="num" id="LN91">91</td><td class="line"> <span class='comment'>of keyword arguments does not change nargsf). kwnames can also be NULL if</span></td></tr> +<tr class="codeline" data-linenumber="92"><td class="num" id="LN92">92</td><td class="line"> <span class='comment'>there are no keyword arguments.</span></td></tr> +<tr class="codeline" data-linenumber="93"><td class="num" id="LN93">93</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="94"><td class="num" id="LN94">94</td><td class="line"> <span class='comment'>keywords must only contain strings and all keys must be unique.</span></td></tr> +<tr class="codeline" data-linenumber="95"><td class="num" id="LN95">95</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="96"><td class="num" id="LN96">96</td><td class="line"> <span class='comment'>Return the result on success. Raise an exception and return NULL on</span></td></tr> +<tr class="codeline" data-linenumber="97"><td class="num" id="LN97">97</td><td class="line"> <span class='comment'>error. */</span></td></tr> +<tr class="codeline" data-linenumber="98"><td class="num" id="LN98">98</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="99"><td class="num" id="LN99">99</td><td class="line">_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable,</td></tr> +<tr class="codeline" data-linenumber="100"><td class="num" id="LN100">100</td><td class="line"> PyObject *<span class='keyword'>const</span> *args, size_t nargsf,</td></tr> +<tr class="codeline" data-linenumber="101"><td class="num" id="LN101">101</td><td class="line"> PyObject *kwnames)</td></tr> +<tr class="codeline" data-linenumber="102"><td class="num" id="LN102">102</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="103"><td class="num" id="LN103">103</td><td class="line"> vectorcallfunc func;</td></tr> +<tr class="codeline" data-linenumber="104"><td class="num" id="LN104">104</td><td class="line"> PyObject *res;</td></tr> +<tr class="codeline" data-linenumber="105"><td class="num" id="LN105">105</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="106"><td class="num" id="LN106">106</td><td class="line"> <span class='macro'>assert(kwnames == NULL || PyTuple_Check(kwnames))<span class='macro_popup'>((void) sizeof ((kwnames == ((void*)0) || PyType_HasFeature((<br>((PyObject*)(kwnames))->ob_type), (1UL << 26))) ? 1 :<br> 0), __extension__ ({ if (kwnames == ((void*)0) || PyType_HasFeature<br>((((PyObject*)(kwnames))->ob_type), (1UL << 26))) ; else<br> __assert_fail ("kwnames == NULL || PyTuple_Check(kwnames)", "/usr/include/python3.10/cpython/abstract.h"<br>, 106, __extension__ __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="107"><td class="num" id="LN107">107</td><td class="line"> <span class='macro'>assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0)<span class='macro_popup'>((void) sizeof ((args != ((void*)0) || PyVectorcall_NARGS(nargsf<br>) == 0) ? 1 : 0), __extension__ ({ if (args != ((void*)0) || PyVectorcall_NARGS<br>(nargsf) == 0) ; else __assert_fail ("args != NULL || PyVectorcall_NARGS(nargsf) == 0"<br>, "/usr/include/python3.10/cpython/abstract.h", 107, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="108"><td class="num" id="LN108">108</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="109"><td class="num" id="LN109">109</td><td class="line"> func = PyVectorcall_Function(callable);</td></tr> +<tr class="codeline" data-linenumber="110"><td class="num" id="LN110">110</td><td class="line"> <span class='keyword'>if</span> (func == <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>) {</td></tr> +<tr class="codeline" data-linenumber="111"><td class="num" id="LN111">111</td><td class="line"> Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);</td></tr> +<tr class="codeline" data-linenumber="112"><td class="num" id="LN112">112</td><td class="line"> <span class='keyword'>return</span> _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames);</td></tr> +<tr class="codeline" data-linenumber="113"><td class="num" id="LN113">113</td><td class="line"> }</td></tr> +<tr class="codeline" data-linenumber="114"><td class="num" id="LN114">114</td><td class="line"> res = func(callable, args, nargsf, kwnames);</td></tr> +<tr class="codeline" data-linenumber="115"><td class="num" id="LN115">115</td><td class="line"> <span class='keyword'>return</span> _Py_CheckFunctionResult(tstate, callable, res, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="116"><td class="num" id="LN116">116</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="117"><td class="num" id="LN117">117</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="118"><td class="num" id="LN118">118</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="119"><td class="num" id="LN119">119</td><td class="line">PyObject_Vectorcall(PyObject *callable, PyObject *<span class='keyword'>const</span> *args,</td></tr> +<tr class="codeline" data-linenumber="120"><td class="num" id="LN120">120</td><td class="line"> size_t nargsf, PyObject *kwnames)</td></tr> +<tr class="codeline" data-linenumber="121"><td class="num" id="LN121">121</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="122"><td class="num" id="LN122">122</td><td class="line"> PyThreadState *tstate = PyThreadState_Get();</td></tr> +<tr class="codeline" data-linenumber="123"><td class="num" id="LN123">123</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallTstate(tstate, callable,</td></tr> +<tr class="codeline" data-linenumber="124"><td class="num" id="LN124">124</td><td class="line"> args, nargsf, kwnames);</td></tr> +<tr class="codeline" data-linenumber="125"><td class="num" id="LN125">125</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="126"><td class="num" id="LN126">126</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="127"><td class="num" id="LN127">127</td><td class="line"><span class='comment'>// Backwards compatibility aliases for API that was provisional in Python 3.8</span></td></tr> +<tr class="codeline" data-linenumber="128"><td class="num" id="LN128">128</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_Vectorcall<span class='macro_popup'>PyObject_Vectorcall</span></span> PyObject_Vectorcall</span></td></tr> +<tr class="codeline" data-linenumber="129"><td class="num" id="LN129">129</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_VectorcallMethod<span class='macro_popup'>PyObject_VectorcallMethod</span></span> PyObject_VectorcallMethod</span></td></tr> +<tr class="codeline" data-linenumber="130"><td class="num" id="LN130">130</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_FastCallDict<span class='macro_popup'>PyObject_VectorcallDict</span></span> PyObject_VectorcallDict</span></td></tr> +<tr class="codeline" data-linenumber="131"><td class="num" id="LN131">131</td><td class="line"><span class='directive'>#define <span class='macro'>_PyVectorcall_Function<span class='macro_popup'>PyVectorcall_Function</span></span> PyVectorcall_Function</span></td></tr> +<tr class="codeline" data-linenumber="132"><td class="num" id="LN132">132</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_CallOneArg<span class='macro_popup'>PyObject_CallOneArg</span></span> PyObject_CallOneArg</span></td></tr> +<tr class="codeline" data-linenumber="133"><td class="num" id="LN133">133</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_CallMethodNoArgs<span class='macro_popup'>PyObject_CallMethodNoArgs</span></span> PyObject_CallMethodNoArgs</span></td></tr> +<tr class="codeline" data-linenumber="134"><td class="num" id="LN134">134</td><td class="line"><span class='directive'>#define <span class='macro'>_PyObject_CallMethodOneArg<span class='macro_popup'>PyObject_CallMethodOneArg</span></span> PyObject_CallMethodOneArg</span></td></tr> +<tr class="codeline" data-linenumber="135"><td class="num" id="LN135">135</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="136"><td class="num" id="LN136">136</td><td class="line"><span class='comment'>/* Same as PyObject_Vectorcall except that keyword arguments are passed as</span></td></tr> +<tr class="codeline" data-linenumber="137"><td class="num" id="LN137">137</td><td class="line"> <span class='comment'>dict, which may be NULL if there are no keyword arguments. */</span></td></tr> +<tr class="codeline" data-linenumber="138"><td class="num" id="LN138">138</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> PyObject_VectorcallDict(</td></tr> +<tr class="codeline" data-linenumber="139"><td class="num" id="LN139">139</td><td class="line"> PyObject *callable,</td></tr> +<tr class="codeline" data-linenumber="140"><td class="num" id="LN140">140</td><td class="line"> PyObject *<span class='keyword'>const</span> *args,</td></tr> +<tr class="codeline" data-linenumber="141"><td class="num" id="LN141">141</td><td class="line"> size_t nargsf,</td></tr> +<tr class="codeline" data-linenumber="142"><td class="num" id="LN142">142</td><td class="line"> PyObject *kwargs);</td></tr> +<tr class="codeline" data-linenumber="143"><td class="num" id="LN143">143</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="144"><td class="num" id="LN144">144</td><td class="line"><span class='comment'>/* Call "callable" (which must support vectorcall) with positional arguments</span></td></tr> +<tr class="codeline" data-linenumber="145"><td class="num" id="LN145">145</td><td class="line"> <span class='comment'>"tuple" and keyword arguments "dict". "dict" may also be NULL */</span></td></tr> +<tr class="codeline" data-linenumber="146"><td class="num" id="LN146">146</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict);</td></tr> +<tr class="codeline" data-linenumber="147"><td class="num" id="LN147">147</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="148"><td class="num" id="LN148">148</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="149"><td class="num" id="LN149">149</td><td class="line">_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *<span class='keyword'>const</span> *args, Py_ssize_t nargs)</td></tr> +<tr class="codeline" data-linenumber="150"><td class="num" id="LN150">150</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="151"><td class="num" id="LN151">151</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="152"><td class="num" id="LN152">152</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="153"><td class="num" id="LN153">153</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="154"><td class="num" id="LN154">154</td><td class="line"><span class='comment'>/* Same as PyObject_Vectorcall except without keyword arguments */</span></td></tr> +<tr class="codeline" data-linenumber="155"><td class="num" id="LN155">155</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="156"><td class="num" id="LN156">156</td><td class="line">_PyObject_FastCall(PyObject *func, PyObject *<span class='keyword'>const</span> *args, Py_ssize_t nargs)</td></tr> +<tr class="codeline" data-linenumber="157"><td class="num" id="LN157">157</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="158"><td class="num" id="LN158">158</td><td class="line"> PyThreadState *tstate = PyThreadState_Get();</td></tr> +<tr class="codeline" data-linenumber="159"><td class="num" id="LN159">159</td><td class="line"> <span class='keyword'>return</span> _PyObject_FastCallTstate(tstate, func, args, nargs);</td></tr> +<tr class="codeline" data-linenumber="160"><td class="num" id="LN160">160</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="161"><td class="num" id="LN161">161</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="162"><td class="num" id="LN162">162</td><td class="line"><span class='comment'>/* Call a callable without any arguments</span></td></tr> +<tr class="codeline" data-linenumber="163"><td class="num" id="LN163">163</td><td class="line"> <span class='comment'>Private static inline function variant of public function</span></td></tr> +<tr class="codeline" data-linenumber="164"><td class="num" id="LN164">164</td><td class="line"> <span class='comment'>PyObject_CallNoArgs(). */</span></td></tr> +<tr class="codeline" data-linenumber="165"><td class="num" id="LN165">165</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="166"><td class="num" id="LN166">166</td><td class="line">_PyObject_CallNoArg(PyObject *func) {</td></tr> +<tr class="codeline" data-linenumber="167"><td class="num" id="LN167">167</td><td class="line"> PyThreadState *tstate = PyThreadState_Get();</td></tr> +<tr class="codeline" data-linenumber="168"><td class="num" id="LN168">168</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallTstate(tstate, func, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>, 0, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="169"><td class="num" id="LN169">169</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="170"><td class="num" id="LN170">170</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="171"><td class="num" id="LN171">171</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="172"><td class="num" id="LN172">172</td><td class="line">PyObject_CallOneArg(PyObject *func, PyObject *arg)</td></tr> +<tr class="codeline" data-linenumber="173"><td class="num" id="LN173">173</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="174"><td class="num" id="LN174">174</td><td class="line"> PyObject *_args[2];</td></tr> +<tr class="codeline" data-linenumber="175"><td class="num" id="LN175">175</td><td class="line"> PyObject **args;</td></tr> +<tr class="codeline" data-linenumber="176"><td class="num" id="LN176">176</td><td class="line"> PyThreadState *tstate;</td></tr> +<tr class="codeline" data-linenumber="177"><td class="num" id="LN177">177</td><td class="line"> size_t nargsf;</td></tr> +<tr class="codeline" data-linenumber="178"><td class="num" id="LN178">178</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="179"><td class="num" id="LN179">179</td><td class="line"> <span class='macro'>assert(arg != NULL)<span class='macro_popup'>((void) sizeof ((arg != ((void*)0)) ? 1 : 0), __extension__ (<br>{ if (arg != ((void*)0)) ; else __assert_fail ("arg != NULL",<br> "/usr/include/python3.10/cpython/abstract.h", 179, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="180"><td class="num" id="LN180">180</td><td class="line"> args = _args + 1; <span class='comment'>// For PY_VECTORCALL_ARGUMENTS_OFFSET</span></td></tr> +<tr class="codeline" data-linenumber="181"><td class="num" id="LN181">181</td><td class="line"> args[0] = arg;</td></tr> +<tr class="codeline" data-linenumber="182"><td class="num" id="LN182">182</td><td class="line"> tstate = PyThreadState_Get();</td></tr> +<tr class="codeline" data-linenumber="183"><td class="num" id="LN183">183</td><td class="line"> nargsf = 1 | <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="184"><td class="num" id="LN184">184</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallTstate(tstate, func, args, nargsf, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="185"><td class="num" id="LN185">185</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="186"><td class="num" id="LN186">186</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="187"><td class="num" id="LN187">187</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> PyObject_VectorcallMethod(</td></tr> +<tr class="codeline" data-linenumber="188"><td class="num" id="LN188">188</td><td class="line"> PyObject *name, PyObject *<span class='keyword'>const</span> *args,</td></tr> +<tr class="codeline" data-linenumber="189"><td class="num" id="LN189">189</td><td class="line"> size_t nargsf, PyObject *kwnames);</td></tr> +<tr class="codeline" data-linenumber="190"><td class="num" id="LN190">190</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="191"><td class="num" id="LN191">191</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="192"><td class="num" id="LN192">192</td><td class="line">PyObject_CallMethodNoArgs(PyObject *self, PyObject *name)</td></tr> +<tr class="codeline" data-linenumber="193"><td class="num" id="LN193">193</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="194"><td class="num" id="LN194">194</td><td class="line"> <span class='keyword'>return</span> PyObject_VectorcallMethod(name, &self,</td></tr> +<tr class="codeline" data-linenumber="195"><td class="num" id="LN195">195</td><td class="line"> 1 | <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="196"><td class="num" id="LN196">196</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="197"><td class="num" id="LN197">197</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="198"><td class="num" id="LN198">198</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="199"><td class="num" id="LN199">199</td><td class="line">PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg)</td></tr> +<tr class="codeline" data-linenumber="200"><td class="num" id="LN200">200</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="201"><td class="num" id="LN201">201</td><td class="line"> PyObject *args[2] = {self, arg};</td></tr> +<tr class="codeline" data-linenumber="202"><td class="num" id="LN202">202</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="203"><td class="num" id="LN203">203</td><td class="line"> <span class='macro'>assert(arg != NULL)<span class='macro_popup'>((void) sizeof ((arg != ((void*)0)) ? 1 : 0), __extension__ (<br>{ if (arg != ((void*)0)) ; else __assert_fail ("arg != NULL",<br> "/usr/include/python3.10/cpython/abstract.h", 203, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="204"><td class="num" id="LN204">204</td><td class="line"> <span class='keyword'>return</span> PyObject_VectorcallMethod(name, args,</td></tr> +<tr class="codeline" data-linenumber="205"><td class="num" id="LN205">205</td><td class="line"> 2 | <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="206"><td class="num" id="LN206">206</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="207"><td class="num" id="LN207">207</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="208"><td class="num" id="LN208">208</td><td class="line"><span class='comment'>/* Like PyObject_CallMethod(), but expect a _Py_Identifier*</span></td></tr> +<tr class="codeline" data-linenumber="209"><td class="num" id="LN209">209</td><td class="line"> <span class='comment'>as the method name. */</span></td></tr> +<tr class="codeline" data-linenumber="210"><td class="num" id="LN210">210</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyObject_CallMethodId(PyObject *obj,</td></tr> +<tr class="codeline" data-linenumber="211"><td class="num" id="LN211">211</td><td class="line"> _Py_Identifier *name,</td></tr> +<tr class="codeline" data-linenumber="212"><td class="num" id="LN212">212</td><td class="line"> <span class='keyword'>const</span> <span class='keyword'>char</span> *format, ...);</td></tr> +<tr class="codeline" data-linenumber="213"><td class="num" id="LN213">213</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="214"><td class="num" id="LN214">214</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyObject_CallMethodId_SizeT(PyObject *obj,</td></tr> +<tr class="codeline" data-linenumber="215"><td class="num" id="LN215">215</td><td class="line"> _Py_Identifier *name,</td></tr> +<tr class="codeline" data-linenumber="216"><td class="num" id="LN216">216</td><td class="line"> <span class='keyword'>const</span> <span class='keyword'>char</span> *format,</td></tr> +<tr class="codeline" data-linenumber="217"><td class="num" id="LN217">217</td><td class="line"> ...);</td></tr> +<tr class="codeline" data-linenumber="218"><td class="num" id="LN218">218</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="219"><td class="num" id="LN219">219</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyObject_CallMethodIdObjArgs(</td></tr> +<tr class="codeline" data-linenumber="220"><td class="num" id="LN220">220</td><td class="line"> PyObject *obj,</td></tr> +<tr class="codeline" data-linenumber="221"><td class="num" id="LN221">221</td><td class="line"> <span class='keyword'>struct</span> _Py_Identifier *name,</td></tr> +<tr class="codeline" data-linenumber="222"><td class="num" id="LN222">222</td><td class="line"> ...);</td></tr> +<tr class="codeline" data-linenumber="223"><td class="num" id="LN223">223</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="224"><td class="num" id="LN224">224</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="225"><td class="num" id="LN225">225</td><td class="line">_PyObject_VectorcallMethodId(</td></tr> +<tr class="codeline" data-linenumber="226"><td class="num" id="LN226">226</td><td class="line"> _Py_Identifier *name, PyObject *<span class='keyword'>const</span> *args,</td></tr> +<tr class="codeline" data-linenumber="227"><td class="num" id="LN227">227</td><td class="line"> size_t nargsf, PyObject *kwnames)</td></tr> +<tr class="codeline" data-linenumber="228"><td class="num" id="LN228">228</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="229"><td class="num" id="LN229">229</td><td class="line"> PyObject *oname = _PyUnicode_FromId(name); <span class='comment'>/* borrowed */</span></td></tr> +<tr class="codeline" data-linenumber="230"><td class="num" id="LN230">230</td><td class="line"> <span class='keyword'>if</span> (!oname) {</td></tr> +<tr class="codeline" data-linenumber="231"><td class="num" id="LN231">231</td><td class="line"> <span class='keyword'>return</span> <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>;</td></tr> +<tr class="codeline" data-linenumber="232"><td class="num" id="LN232">232</td><td class="line"> }</td></tr> +<tr class="codeline" data-linenumber="233"><td class="num" id="LN233">233</td><td class="line"> <span class='keyword'>return</span> PyObject_VectorcallMethod(oname, args, nargsf, kwnames);</td></tr> +<tr class="codeline" data-linenumber="234"><td class="num" id="LN234">234</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="235"><td class="num" id="LN235">235</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="236"><td class="num" id="LN236">236</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="237"><td class="num" id="LN237">237</td><td class="line">_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name)</td></tr> +<tr class="codeline" data-linenumber="238"><td class="num" id="LN238">238</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="239"><td class="num" id="LN239">239</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallMethodId(name, &self,</td></tr> +<tr class="codeline" data-linenumber="240"><td class="num" id="LN240">240</td><td class="line"> 1 | <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="241"><td class="num" id="LN241">241</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="242"><td class="num" id="LN242">242</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="243"><td class="num" id="LN243">243</td><td class="line"><span class='keyword'>static</span> <span class='keyword'>inline</span> PyObject *</td></tr> +<tr class="codeline" data-linenumber="244"><td class="num" id="LN244">244</td><td class="line">_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg)</td></tr> +<tr class="codeline" data-linenumber="245"><td class="num" id="LN245">245</td><td class="line">{</td></tr> +<tr class="codeline" data-linenumber="246"><td class="num" id="LN246">246</td><td class="line"> PyObject *args[2] = {self, arg};</td></tr> +<tr class="codeline" data-linenumber="247"><td class="num" id="LN247">247</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="248"><td class="num" id="LN248">248</td><td class="line"> <span class='macro'>assert(arg != NULL)<span class='macro_popup'>((void) sizeof ((arg != ((void*)0)) ? 1 : 0), __extension__ (<br>{ if (arg != ((void*)0)) ; else __assert_fail ("arg != NULL",<br> "/usr/include/python3.10/cpython/abstract.h", 248, __extension__<br> __PRETTY_FUNCTION__); }))</span></span>;</td></tr> +<tr class="codeline" data-linenumber="249"><td class="num" id="LN249">249</td><td class="line"> <span class='keyword'>return</span> _PyObject_VectorcallMethodId(name, args,</td></tr> +<tr class="codeline" data-linenumber="250"><td class="num" id="LN250">250</td><td class="line"> 2 | <span class='macro'>PY_VECTORCALL_ARGUMENTS_OFFSET<span class='macro_popup'>((size_t)1 << (8 * sizeof(size_t) - 1))</span></span>, <span class='macro'>NULL<span class='macro_popup'>((void*)0)</span></span>);</td></tr> +<tr class="codeline" data-linenumber="251"><td class="num" id="LN251">251</td><td class="line">}</td></tr> +<tr class="codeline" data-linenumber="252"><td class="num" id="LN252">252</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="253"><td class="num" id="LN253">253</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> _PyObject_HasLen(PyObject *o);</td></tr> +<tr class="codeline" data-linenumber="254"><td class="num" id="LN254">254</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="255"><td class="num" id="LN255">255</td><td class="line"><span class='comment'>/* Guess the size of object 'o' using len(o) or o.__length_hint__().</span></td></tr> +<tr class="codeline" data-linenumber="256"><td class="num" id="LN256">256</td><td class="line"> <span class='comment'>If neither of those return a non-negative value, then return the default</span></td></tr> +<tr class="codeline" data-linenumber="257"><td class="num" id="LN257">257</td><td class="line"> <span class='comment'>value. If one of the calls fails, this function returns -1. */</span></td></tr> +<tr class="codeline" data-linenumber="258"><td class="num" id="LN258">258</td><td class="line"><span class='macro'>PyAPI_FUNC(Py_ssize_t)<span class='macro_popup'>__attribute__ ((visibility ("default"))) Py_ssize_t</span></span> PyObject_LengthHint(PyObject *o, Py_ssize_t);</td></tr> +<tr class="codeline" data-linenumber="259"><td class="num" id="LN259">259</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="260"><td class="num" id="LN260">260</td><td class="line"><span class='comment'>/* === New Buffer API ============================================ */</span></td></tr> +<tr class="codeline" data-linenumber="261"><td class="num" id="LN261">261</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="262"><td class="num" id="LN262">262</td><td class="line"><span class='comment'>/* Return 1 if the getbuffer function is available, otherwise return 0. */</span></td></tr> +<tr class="codeline" data-linenumber="263"><td class="num" id="LN263">263</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyObject_CheckBuffer(PyObject *obj);</td></tr> +<tr class="codeline" data-linenumber="264"><td class="num" id="LN264">264</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="265"><td class="num" id="LN265">265</td><td class="line"><span class='comment'>/* This is a C-API version of the getbuffer function call. It checks</span></td></tr> +<tr class="codeline" data-linenumber="266"><td class="num" id="LN266">266</td><td class="line"> <span class='comment'>to make sure object has the required function pointer and issues the</span></td></tr> +<tr class="codeline" data-linenumber="267"><td class="num" id="LN267">267</td><td class="line"> <span class='comment'>call.</span></td></tr> +<tr class="codeline" data-linenumber="268"><td class="num" id="LN268">268</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="269"><td class="num" id="LN269">269</td><td class="line"> <span class='comment'>Returns -1 and raises an error on failure and returns 0 on success. */</span></td></tr> +<tr class="codeline" data-linenumber="270"><td class="num" id="LN270">270</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyObject_GetBuffer(PyObject *obj, Py_buffer *view,</td></tr> +<tr class="codeline" data-linenumber="271"><td class="num" id="LN271">271</td><td class="line"> <span class='keyword'>int</span> flags);</td></tr> +<tr class="codeline" data-linenumber="272"><td class="num" id="LN272">272</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="273"><td class="num" id="LN273">273</td><td class="line"><span class='comment'>/* Get the memory area pointed to by the indices for the buffer given.</span></td></tr> +<tr class="codeline" data-linenumber="274"><td class="num" id="LN274">274</td><td class="line"> <span class='comment'>Note that view->ndim is the assumed size of indices. */</span></td></tr> +<tr class="codeline" data-linenumber="275"><td class="num" id="LN275">275</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span> *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void *</span></span> PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);</td></tr> +<tr class="codeline" data-linenumber="276"><td class="num" id="LN276">276</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="277"><td class="num" id="LN277">277</td><td class="line"><span class='comment'>/* Return the implied itemsize of the data-format area from a</span></td></tr> +<tr class="codeline" data-linenumber="278"><td class="num" id="LN278">278</td><td class="line"> <span class='comment'>struct-style description. */</span></td></tr> +<tr class="codeline" data-linenumber="279"><td class="num" id="LN279">279</td><td class="line"><span class='macro'>PyAPI_FUNC(Py_ssize_t)<span class='macro_popup'>__attribute__ ((visibility ("default"))) Py_ssize_t</span></span> PyBuffer_SizeFromFormat(<span class='keyword'>const</span> <span class='keyword'>char</span> *format);</td></tr> +<tr class="codeline" data-linenumber="280"><td class="num" id="LN280">280</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="281"><td class="num" id="LN281">281</td><td class="line"><span class='comment'>/* Implementation in memoryobject.c */</span></td></tr> +<tr class="codeline" data-linenumber="282"><td class="num" id="LN282">282</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyBuffer_ToContiguous(<span class='keyword'>void</span> *buf, Py_buffer *view,</td></tr> +<tr class="codeline" data-linenumber="283"><td class="num" id="LN283">283</td><td class="line"> Py_ssize_t len, <span class='keyword'>char</span> order);</td></tr> +<tr class="codeline" data-linenumber="284"><td class="num" id="LN284">284</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="285"><td class="num" id="LN285">285</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyBuffer_FromContiguous(Py_buffer *view, <span class='keyword'>void</span> *buf,</td></tr> +<tr class="codeline" data-linenumber="286"><td class="num" id="LN286">286</td><td class="line"> Py_ssize_t len, <span class='keyword'>char</span> order);</td></tr> +<tr class="codeline" data-linenumber="287"><td class="num" id="LN287">287</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="288"><td class="num" id="LN288">288</td><td class="line"><span class='comment'>/* Copy len bytes of data from the contiguous chunk of memory</span></td></tr> +<tr class="codeline" data-linenumber="289"><td class="num" id="LN289">289</td><td class="line"> <span class='comment'>pointed to by buf into the buffer exported by obj. Return</span></td></tr> +<tr class="codeline" data-linenumber="290"><td class="num" id="LN290">290</td><td class="line"> <span class='comment'>0 on success and return -1 and raise a PyBuffer_Error on</span></td></tr> +<tr class="codeline" data-linenumber="291"><td class="num" id="LN291">291</td><td class="line"> <span class='comment'>error (i.e. the object does not have a buffer interface or</span></td></tr> +<tr class="codeline" data-linenumber="292"><td class="num" id="LN292">292</td><td class="line"> <span class='comment'>it is not working).</span></td></tr> +<tr class="codeline" data-linenumber="293"><td class="num" id="LN293">293</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="294"><td class="num" id="LN294">294</td><td class="line"> <span class='comment'>If fort is 'F', then if the object is multi-dimensional,</span></td></tr> +<tr class="codeline" data-linenumber="295"><td class="num" id="LN295">295</td><td class="line"> <span class='comment'>then the data will be copied into the array in</span></td></tr> +<tr class="codeline" data-linenumber="296"><td class="num" id="LN296">296</td><td class="line"> <span class='comment'>Fortran-style (first dimension varies the fastest). If</span></td></tr> +<tr class="codeline" data-linenumber="297"><td class="num" id="LN297">297</td><td class="line"> <span class='comment'>fort is 'C', then the data will be copied into the array</span></td></tr> +<tr class="codeline" data-linenumber="298"><td class="num" id="LN298">298</td><td class="line"> <span class='comment'>in C-style (last dimension varies the fastest). If fort</span></td></tr> +<tr class="codeline" data-linenumber="299"><td class="num" id="LN299">299</td><td class="line"> <span class='comment'>is 'A', then it does not matter and the copy will be made</span></td></tr> +<tr class="codeline" data-linenumber="300"><td class="num" id="LN300">300</td><td class="line"> <span class='comment'>in whatever way is more efficient. */</span></td></tr> +<tr class="codeline" data-linenumber="301"><td class="num" id="LN301">301</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyObject_CopyData(PyObject *dest, PyObject *src);</td></tr> +<tr class="codeline" data-linenumber="302"><td class="num" id="LN302">302</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="303"><td class="num" id="LN303">303</td><td class="line"><span class='comment'>/* Copy the data from the src buffer to the buffer of destination. */</span></td></tr> +<tr class="codeline" data-linenumber="304"><td class="num" id="LN304">304</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyBuffer_IsContiguous(<span class='keyword'>const</span> Py_buffer *view, <span class='keyword'>char</span> fort);</td></tr> +<tr class="codeline" data-linenumber="305"><td class="num" id="LN305">305</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="306"><td class="num" id="LN306">306</td><td class="line"><span class='comment'>/*Fill the strides array with byte-strides of a contiguous</span></td></tr> +<tr class="codeline" data-linenumber="307"><td class="num" id="LN307">307</td><td class="line"> <span class='comment'>(Fortran-style if fort is 'F' or C-style otherwise)</span></td></tr> +<tr class="codeline" data-linenumber="308"><td class="num" id="LN308">308</td><td class="line"> <span class='comment'>array of the given shape with the given number of bytes</span></td></tr> +<tr class="codeline" data-linenumber="309"><td class="num" id="LN309">309</td><td class="line"> <span class='comment'>per element. */</span></td></tr> +<tr class="codeline" data-linenumber="310"><td class="num" id="LN310">310</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void</span></span> PyBuffer_FillContiguousStrides(<span class='keyword'>int</span> ndims,</td></tr> +<tr class="codeline" data-linenumber="311"><td class="num" id="LN311">311</td><td class="line"> Py_ssize_t *shape,</td></tr> +<tr class="codeline" data-linenumber="312"><td class="num" id="LN312">312</td><td class="line"> Py_ssize_t *strides,</td></tr> +<tr class="codeline" data-linenumber="313"><td class="num" id="LN313">313</td><td class="line"> <span class='keyword'>int</span> itemsize,</td></tr> +<tr class="codeline" data-linenumber="314"><td class="num" id="LN314">314</td><td class="line"> <span class='keyword'>char</span> fort);</td></tr> +<tr class="codeline" data-linenumber="315"><td class="num" id="LN315">315</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="316"><td class="num" id="LN316">316</td><td class="line"><span class='comment'>/* Fills in a buffer-info structure correctly for an exporter</span></td></tr> +<tr class="codeline" data-linenumber="317"><td class="num" id="LN317">317</td><td class="line"> <span class='comment'>that can only share a contiguous chunk of memory of</span></td></tr> +<tr class="codeline" data-linenumber="318"><td class="num" id="LN318">318</td><td class="line"> <span class='comment'>"unsigned bytes" of the given length.</span></td></tr> +<tr class="codeline" data-linenumber="319"><td class="num" id="LN319">319</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="320"><td class="num" id="LN320">320</td><td class="line"> <span class='comment'>Returns 0 on success and -1 (with raising an error) on error. */</span></td></tr> +<tr class="codeline" data-linenumber="321"><td class="num" id="LN321">321</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> PyBuffer_FillInfo(Py_buffer *view, PyObject *o, <span class='keyword'>void</span> *buf,</td></tr> +<tr class="codeline" data-linenumber="322"><td class="num" id="LN322">322</td><td class="line"> Py_ssize_t len, <span class='keyword'>int</span> readonly,</td></tr> +<tr class="codeline" data-linenumber="323"><td class="num" id="LN323">323</td><td class="line"> <span class='keyword'>int</span> flags);</td></tr> +<tr class="codeline" data-linenumber="324"><td class="num" id="LN324">324</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="325"><td class="num" id="LN325">325</td><td class="line"><span class='comment'>/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */</span></td></tr> +<tr class="codeline" data-linenumber="326"><td class="num" id="LN326">326</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void</span></span> PyBuffer_Release(Py_buffer *view);</td></tr> +<tr class="codeline" data-linenumber="327"><td class="num" id="LN327">327</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="328"><td class="num" id="LN328">328</td><td class="line"><span class='comment'>/* === Sequence protocol ================================================ */</span></td></tr> +<tr class="codeline" data-linenumber="329"><td class="num" id="LN329">329</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="330"><td class="num" id="LN330">330</td><td class="line"><span class='comment'>/* Assume tp_as_sequence and sq_item exist and that 'i' does not</span></td></tr> +<tr class="codeline" data-linenumber="331"><td class="num" id="LN331">331</td><td class="line"> <span class='comment'>need to be corrected for a negative index. */</span></td></tr> +<tr class="codeline" data-linenumber="332"><td class="num" id="LN332">332</td><td class="line"><span class='directive'>#define <span class='macro'>PySequence_ITEM(o, i)<span class='macro_popup'>( (((PyObject*)(o))->ob_type)->tp_as_sequence->sq_item<br>(o, i) )</span></span>\</span></td></tr> +<tr class="codeline" data-linenumber="333"><td class="num" id="LN333">333</td><td class="line"> <span class='directive'>( <span class='macro'>Py_TYPE(o)<span class='macro_popup'>(((PyObject*)(o))->ob_type)</span></span>->tp_as_sequence->sq_item(o, i) )</span></td></tr> +<tr class="codeline" data-linenumber="334"><td class="num" id="LN334">334</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="335"><td class="num" id="LN335">335</td><td class="line"><span class='directive'>#define <span class='macro'>PY_ITERSEARCH_COUNT<span class='macro_popup'>1</span></span> 1</span></td></tr> +<tr class="codeline" data-linenumber="336"><td class="num" id="LN336">336</td><td class="line"><span class='directive'>#define <span class='macro'>PY_ITERSEARCH_INDEX<span class='macro_popup'>2</span></span> 2</span></td></tr> +<tr class="codeline" data-linenumber="337"><td class="num" id="LN337">337</td><td class="line"><span class='directive'>#define <span class='macro'>PY_ITERSEARCH_CONTAINS<span class='macro_popup'>3</span></span> 3</span></td></tr> +<tr class="codeline" data-linenumber="338"><td class="num" id="LN338">338</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="339"><td class="num" id="LN339">339</td><td class="line"><span class='comment'>/* Iterate over seq.</span></td></tr> +<tr class="codeline" data-linenumber="340"><td class="num" id="LN340">340</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="341"><td class="num" id="LN341">341</td><td class="line"> <span class='comment'>Result depends on the operation:</span></td></tr> +<tr class="codeline" data-linenumber="342"><td class="num" id="LN342">342</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="343"><td class="num" id="LN343">343</td><td class="line"> <span class='comment'>PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if</span></td></tr> +<tr class="codeline" data-linenumber="344"><td class="num" id="LN344">344</td><td class="line"> <span class='comment'>error.</span></td></tr> +<tr class="codeline" data-linenumber="345"><td class="num" id="LN345">345</td><td class="line"> <span class='comment'>PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of</span></td></tr> +<tr class="codeline" data-linenumber="346"><td class="num" id="LN346">346</td><td class="line"> <span class='comment'>obj in seq; set ValueError and return -1 if none found;</span></td></tr> +<tr class="codeline" data-linenumber="347"><td class="num" id="LN347">347</td><td class="line"> <span class='comment'>also return -1 on error.</span></td></tr> +<tr class="codeline" data-linenumber="348"><td class="num" id="LN348">348</td><td class="line"> <span class='comment'>PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on</span></td></tr> +<tr class="codeline" data-linenumber="349"><td class="num" id="LN349">349</td><td class="line"> <span class='comment'>error. */</span></td></tr> +<tr class="codeline" data-linenumber="350"><td class="num" id="LN350">350</td><td class="line"><span class='macro'>PyAPI_FUNC(Py_ssize_t)<span class='macro_popup'>__attribute__ ((visibility ("default"))) Py_ssize_t</span></span> _PySequence_IterSearch(PyObject *seq,</td></tr> +<tr class="codeline" data-linenumber="351"><td class="num" id="LN351">351</td><td class="line"> PyObject *obj, <span class='keyword'>int</span> operation);</td></tr> +<tr class="codeline" data-linenumber="352"><td class="num" id="LN352">352</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="353"><td class="num" id="LN353">353</td><td class="line"><span class='comment'>/* === Mapping protocol ================================================= */</span></td></tr> +<tr class="codeline" data-linenumber="354"><td class="num" id="LN354">354</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="355"><td class="num" id="LN355">355</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);</td></tr> +<tr class="codeline" data-linenumber="356"><td class="num" id="LN356">356</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="357"><td class="num" id="LN357">357</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);</td></tr> +<tr class="codeline" data-linenumber="358"><td class="num" id="LN358">358</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="359"><td class="num" id="LN359">359</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>char</span> *<span class='keyword'>const</span> *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) char *const *</span></span> _PySequence_BytesToCharpArray(PyObject* self);</td></tr> +<tr class="codeline" data-linenumber="360"><td class="num" id="LN360">360</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="361"><td class="num" id="LN361">361</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void</span></span> _Py_FreeCharPArray(<span class='keyword'>char</span> *<span class='keyword'>const</span> array[]);</td></tr> +<tr class="codeline" data-linenumber="362"><td class="num" id="LN362">362</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="363"><td class="num" id="LN363">363</td><td class="line"><span class='comment'>/* For internal use by buffer API functions */</span></td></tr> +<tr class="codeline" data-linenumber="364"><td class="num" id="LN364">364</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void</span></span> _Py_add_one_to_index_F(<span class='keyword'>int</span> nd, Py_ssize_t *index,</td></tr> +<tr class="codeline" data-linenumber="365"><td class="num" id="LN365">365</td><td class="line"> <span class='keyword'>const</span> Py_ssize_t *shape);</td></tr> +<tr class="codeline" data-linenumber="366"><td class="num" id="LN366">366</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>void</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) void</span></span> _Py_add_one_to_index_C(<span class='keyword'>int</span> nd, Py_ssize_t *index,</td></tr> +<tr class="codeline" data-linenumber="367"><td class="num" id="LN367">367</td><td class="line"> <span class='keyword'>const</span> Py_ssize_t *shape);</td></tr> +<tr class="codeline" data-linenumber="368"><td class="num" id="LN368">368</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="369"><td class="num" id="LN369">369</td><td class="line"><span class='comment'>/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */</span></td></tr> +<tr class="codeline" data-linenumber="370"><td class="num" id="LN370">370</td><td class="line"><span class='macro'>PyAPI_FUNC(<span class='keyword'>int</span>)<span class='macro_popup'>__attribute__ ((visibility ("default"))) int</span></span> _Py_convert_optional_to_ssize_t(PyObject *, <span class='keyword'>void</span> *);</td></tr> +<tr class="codeline" data-linenumber="371"><td class="num" id="LN371">371</td><td class="line"> </td></tr> +<tr class="codeline" data-linenumber="372"><td class="num" id="LN372">372</td><td class="line"><span class='comment'>/* Same as PyNumber_Index but can return an instance of a subclass of int. */</span></td></tr> +<tr class="codeline" data-linenumber="373"><td class="num" id="LN373">373</td><td class="line"><span class='macro'>PyAPI_FUNC(PyObject *)<span class='macro_popup'>__attribute__ ((visibility ("default"))) PyObject *</span></span> _PyNumber_Index(PyObject *o);</td></tr> +</table></body></html> diff --git a/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/scanview.css b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/scanview.css new file mode 100644 index 0000000..cf8a5a6 --- /dev/null +++ b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/scanview.css @@ -0,0 +1,62 @@ +body { color:#000000; background-color:#ffffff } +body { font-family: Helvetica, sans-serif; font-size:9pt } +h1 { font-size: 14pt; } +h2 { font-size: 12pt; } +table { font-size:9pt } +table { border-spacing: 0px; border: 1px solid black } +th, table thead { + background-color:#eee; color:#666666; + font-weight: bold; cursor: default; + text-align:center; + font-weight: bold; font-family: Verdana; + white-space:nowrap; +} +.W { font-size:0px } +th, td { padding:5px; padding-left:8px; text-align:left } +td.SUMM_DESC { padding-left:12px } +td.DESC { white-space:pre } +td.Q { text-align:right } +td { text-align:left } +tbody.scrollContent { overflow:auto } + +table.form_group { + background-color: #ccc; + border: 1px solid #333; + padding: 2px; +} + +table.form_inner_group { + background-color: #ccc; + border: 1px solid #333; + padding: 0px; +} + +table.form { + background-color: #999; + border: 1px solid #333; + padding: 2px; +} + +td.form_label { + text-align: right; + vertical-align: top; +} +/* For one line entires */ +td.form_clabel { + text-align: right; + vertical-align: center; +} +td.form_value { + text-align: left; + vertical-align: top; +} +td.form_submit { + text-align: right; + vertical-align: top; +} + +h1.SubmitFail { + color: #f00; +} +h1.SubmitOk { +} diff --git a/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/sorttable.js b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/sorttable.js new file mode 100644 index 0000000..32faa07 --- /dev/null +++ b/2022-11-11-201852-5591-1@779bfe1003e7_v1.27.0/sorttable.js @@ -0,0 +1,492 @@ +/* + SortTable + version 2 + 7th April 2007 + Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/ + + Instructions: + Download this file + Add <script src="sorttable.js"></script> to your HTML + Add class="sortable" to any table you'd like to make sortable + Click on the headers to sort + + Thanks to many, many people for contributions and suggestions. + Licenced as X11: http://www.kryogenix.org/code/browser/licence.html + This basically means: do what you want with it. +*/ + + +var stIsIE = /*@cc_on!@*/false; + +sorttable = { + init: function() { + // quit if this function has already been called + if (arguments.callee.done) return; + // flag this function so we don't do the same thing twice + arguments.callee.done = true; + // kill the timer + if (_timer) clearInterval(_timer); + + if (!document.createElement || !document.getElementsByTagName) return; + + sorttable.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/; + + forEach(document.getElementsByTagName('table'), function(table) { + if (table.className.search(/\bsortable\b/) != -1) { + sorttable.makeSortable(table); + } + }); + + }, + + makeSortable: function(table) { + if (table.getElementsByTagName('thead').length == 0) { + // table doesn't have a tHead. Since it should have, create one and + // put the first table row in it. + the = document.createElement('thead'); + the.appendChild(table.rows[0]); + table.insertBefore(the,table.firstChild); + } + // Safari doesn't support table.tHead, sigh + if (table.tHead == null) table.tHead = table.getElementsByTagName('thead')[0]; + + if (table.tHead.rows.length != 1) return; // can't cope with two header rows + + // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as + // "total" rows, for example). This is B&R, since what you're supposed + // to do is put them in a tfoot. So, if there are sortbottom rows, + // for backward compatibility, move them to tfoot (creating it if needed). + sortbottomrows = []; + for (var i=0; i<table.rows.length; i++) { + if (table.rows[i].className.search(/\bsortbottom\b/) != -1) { + sortbottomrows[sortbottomrows.length] = table.rows[i]; + } + } + if (sortbottomrows) { + if (table.tFoot == null) { + // table doesn't have a tfoot. Create one. + tfo = document.createElement('tfoot'); + table.appendChild(tfo); + } + for (var i=0; i<sortbottomrows.length; i++) { + tfo.appendChild(sortbottomrows[i]); + } + delete sortbottomrows; + } + + // work through each column and calculate its type + headrow = table.tHead.rows[0].cells; + for (var i=0; i<headrow.length; i++) { + // manually override the type with a sorttable_type attribute + if (!headrow[i].className.match(/\bsorttable_nosort\b/)) { // skip this col + mtch = headrow[i].className.match(/\bsorttable_([a-z0-9]+)\b/); + if (mtch) { override = mtch[1]; } + if (mtch && typeof sorttable["sort_"+override] == 'function') { + headrow[i].sorttable_sortfunction = sorttable["sort_"+override]; + } else { + headrow[i].sorttable_sortfunction = sorttable.guessType(table,i); + } + // make it clickable to sort + headrow[i].sorttable_columnindex = i; + headrow[i].sorttable_tbody = table.tBodies[0]; + dean_addEvent(headrow[i],"click", function(e) { + + if (this.className.search(/\bsorttable_sorted\b/) != -1) { + // if we're already sorted by this column, just + // reverse the table, which is quicker + sorttable.reverse(this.sorttable_tbody); + this.className = this.className.replace('sorttable_sorted', + 'sorttable_sorted_reverse'); + this.removeChild(document.getElementById('sorttable_sortfwdind')); + sortrevind = document.createElement('span'); + sortrevind.id = "sorttable_sortrevind"; + sortrevind.innerHTML = stIsIE ? ' <font face="webdings">5</font>' : ' ▴'; + this.appendChild(sortrevind); + return; + } + if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) { + // if we're already sorted by this column in reverse, just + // re-reverse the table, which is quicker + sorttable.reverse(this.sorttable_tbody); + this.className = this.className.replace('sorttable_sorted_reverse', + 'sorttable_sorted'); + this.removeChild(document.getElementById('sorttable_sortrevind')); + sortfwdind = document.createElement('span'); + sortfwdind.id = "sorttable_sortfwdind"; + sortfwdind.innerHTML = stIsIE ? ' <font face="webdings">6</font>' : ' ▾'; + this.appendChild(sortfwdind); + return; + } + + // remove sorttable_sorted classes + theadrow = this.parentNode; + forEach(theadrow.childNodes, function(cell) { + if (cell.nodeType == 1) { // an element + cell.className = cell.className.replace('sorttable_sorted_reverse',''); + cell.className = cell.className.replace('sorttable_sorted',''); + } + }); + sortfwdind = document.getElementById('sorttable_sortfwdind'); + if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); } + sortrevind = document.getElementById('sorttable_sortrevind'); + if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); } + + this.className += ' sorttable_sorted'; + sortfwdind = document.createElement('span'); + sortfwdind.id = "sorttable_sortfwdind"; + sortfwdind.innerHTML = stIsIE ? ' <font face="webdings">6</font>' : ' ▾'; + this.appendChild(sortfwdind); + + // build an array to sort. This is a Schwartzian transform thing, + // i.e., we "decorate" each row with the actual sort key, + // sort based on the sort keys, and then put the rows back in order + // which is a lot faster because you only do getInnerText once per row + row_array = []; + col = this.sorttable_columnindex; + rows = this.sorttable_tbody.rows; + for (var j=0; j<rows.length; j++) { + row_array[row_array.length] = [sorttable.getInnerText(rows[j].cells[col]), rows[j]]; + } + /* If you want a stable sort, uncomment the following line */ + sorttable.shaker_sort(row_array, this.sorttable_sortfunction); + /* and comment out this one */ + //row_array.sort(this.sorttable_sortfunction); + + tb = this.sorttable_tbody; + for (var j=0; j<row_array.length; j++) { + tb.appendChild(row_array[j][1]); + } + + delete row_array; + }); + } + } + }, + + guessType: function(table, column) { + // guess the type of a column based on its first non-blank row + sortfn = sorttable.sort_alpha; + for (var i=0; i<table.tBodies[0].rows.length; i++) { + text = sorttable.getInnerText(table.tBodies[0].rows[i].cells[column]); + if (text != '') { + if (text.match(/^-?[�$�]?[\d,.]+%?$/)) { + return sorttable.sort_numeric; + } + // check for a date: dd/mm/yyyy or dd/mm/yy + // can have / or . or - as separator + // can be mm/dd as well + possdate = text.match(sorttable.DATE_RE) + if (possdate) { + // looks like a date + first = parseInt(possdate[1]); + second = parseInt(possdate[2]); + if (first > 12) { + // definitely dd/mm + return sorttable.sort_ddmm; + } else if (second > 12) { + return sorttable.sort_mmdd; + } else { + // looks like a date, but we can't tell which, so assume + // that it's dd/mm (English imperialism!) and keep looking + sortfn = sorttable.sort_ddmm; + } + } + } + } + return sortfn; + }, + + getInnerText: function(node) { + // gets the text we want to use for sorting for a cell. + // strips leading and trailing whitespace. + // this is *not* a generic getInnerText function; it's special to sorttable. + // for example, you can override the cell text with a customkey attribute. + // it also gets .value for <input> fields. + + hasInputs = (typeof node.getElementsByTagName == 'function') && + node.getElementsByTagName('input').length; + + if (node.getAttribute("sorttable_customkey") != null) { + return node.getAttribute("sorttable_customkey"); + } + else if (typeof node.textContent != 'undefined' && !hasInputs) { + return node.textContent.replace(/^\s+|\s+$/g, ''); + } + else if (typeof node.innerText != 'undefined' && !hasInputs) { + return node.innerText.replace(/^\s+|\s+$/g, ''); + } + else if (typeof node.text != 'undefined' && !hasInputs) { + return node.text.replace(/^\s+|\s+$/g, ''); + } + else { + switch (node.nodeType) { + case 3: + if (node.nodeName.toLowerCase() == 'input') { + return node.value.replace(/^\s+|\s+$/g, ''); + } + case 4: + return node.nodeValue.replace(/^\s+|\s+$/g, ''); + break; + case 1: + case 11: + var innerText = ''; + for (var i = 0; i < node.childNodes.length; i++) { + innerText += sorttable.getInnerText(node.childNodes[i]); + } + return innerText.replace(/^\s+|\s+$/g, ''); + break; + default: + return ''; + } + } + }, + + reverse: function(tbody) { + // reverse the rows in a tbody + newrows = []; + for (var i=0; i<tbody.rows.length; i++) { + newrows[newrows.length] = tbody.rows[i]; + } + for (var i=newrows.length-1; i>=0; i--) { + tbody.appendChild(newrows[i]); + } + delete newrows; + }, + + /* sort functions + each sort function takes two parameters, a and b + you are comparing a[0] and b[0] */ + sort_numeric: function(a,b) { + aa = parseFloat(a[0].replace(/[^0-9.-]/g,'')); + if (isNaN(aa)) aa = 0; + bb = parseFloat(b[0].replace(/[^0-9.-]/g,'')); + if (isNaN(bb)) bb = 0; + return aa-bb; + }, + sort_alpha: function(a,b) { + if (a[0]==b[0]) return 0; + if (a[0]<b[0]) return -1; + return 1; + }, + sort_ddmm: function(a,b) { + mtch = a[0].match(sorttable.DATE_RE); + y = mtch[3]; m = mtch[2]; d = mtch[1]; + if (m.length == 1) m = '0'+m; + if (d.length == 1) d = '0'+d; + dt1 = y+m+d; + mtch = b[0].match(sorttable.DATE_RE); + y = mtch[3]; m = mtch[2]; d = mtch[1]; + if (m.length == 1) m = '0'+m; + if (d.length == 1) d = '0'+d; + dt2 = y+m+d; + if (dt1==dt2) return 0; + if (dt1<dt2) return -1; + return 1; + }, + sort_mmdd: function(a,b) { + mtch = a[0].match(sorttable.DATE_RE); + y = mtch[3]; d = mtch[2]; m = mtch[1]; + if (m.length == 1) m = '0'+m; + if (d.length == 1) d = '0'+d; + dt1 = y+m+d; + mtch = b[0].match(sorttable.DATE_RE); + y = mtch[3]; d = mtch[2]; m = mtch[1]; + if (m.length == 1) m = '0'+m; + if (d.length == 1) d = '0'+d; + dt2 = y+m+d; + if (dt1==dt2) return 0; + if (dt1<dt2) return -1; + return 1; + }, + + shaker_sort: function(list, comp_func) { + // A stable sort function to allow multi-level sorting of data + // see: http://en.wikipedia.org/wiki/Cocktail_sort + // thanks to Joseph Nahmias + var b = 0; + var t = list.length - 1; + var swap = true; + + while(swap) { + swap = false; + for(var i = b; i < t; ++i) { + if ( comp_func(list[i], list[i+1]) > 0 ) { + var q = list[i]; list[i] = list[i+1]; list[i+1] = q; + swap = true; + } + } // for + t--; + + if (!swap) break; + + for(var i = t; i > b; --i) { + if ( comp_func(list[i], list[i-1]) < 0 ) { + var q = list[i]; list[i] = list[i-1]; list[i-1] = q; + swap = true; + } + } // for + b++; + + } // while(swap) + } +} + +/* ****************************************************************** + Supporting functions: bundled here to avoid depending on a library + ****************************************************************** */ + +// Dean Edwards/Matthias Miller/John Resig + +/* for Mozilla/Opera9 */ +if (document.addEventListener) { + document.addEventListener("DOMContentLoaded", sorttable.init, false); +} + +/* for Internet Explorer */ +/*@cc_on @*/ +/*@if (@_win32) + document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>"); + var script = document.getElementById("__ie_onload"); + script.onreadystatechange = function() { + if (this.readyState == "complete") { + sorttable.init(); // call the onload handler + } + }; +/*@end @*/ + +/* for Safari */ +if (/WebKit/i.test(navigator.userAgent)) { // sniff + var _timer = setInterval(function() { + if (/loaded|complete/.test(document.readyState)) { + sorttable.init(); // call the onload handler + } + }, 10); +} + +/* for other browsers */ +window.onload = sorttable.init; + +// written by Dean Edwards, 2005 +// with input from Tino Zijdel, Matthias Miller, Diego Perini + +// http://dean.edwards.name/weblog/2005/10/add-event/ + +function dean_addEvent(element, type, handler) { + if (element.addEventListener) { + element.addEventListener(type, handler, false); + } else { + // assign each event handler a unique ID + if (!handler.$$guid) handler.$$guid = dean_addEvent.guid++; + // create a hash table of event types for the element + if (!element.events) element.events = {}; + // create a hash table of event handlers for each element/event pair + var handlers = element.events[type]; + if (!handlers) { + handlers = element.events[type] = {}; + // store the existing event handler (if there is one) + if (element["on" + type]) { + handlers[0] = element["on" + type]; + } + } + // store the event handler in the hash table + handlers[handler.$$guid] = handler; + // assign a global event handler to do all the work + element["on" + type] = handleEvent; + } +}; +// a counter used to create unique IDs +dean_addEvent.guid = 1; + +function removeEvent(element, type, handler) { + if (element.removeEventListener) { + element.removeEventListener(type, handler, false); + } else { + // delete the event handler from the hash table + if (element.events && element.events[type]) { + delete element.events[type][handler.$$guid]; + } + } +}; + +function handleEvent(event) { + var returnValue = true; + // grab the event object (IE uses a global event object) + event = event || fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event); + // get a reference to the hash table of event handlers + var handlers = this.events[event.type]; + // execute each event handler + for (var i in handlers) { + this.$$handleEvent = handlers[i]; + if (this.$$handleEvent(event) === false) { + returnValue = false; + } + } + return returnValue; +}; + +function fixEvent(event) { + // add W3C standard event methods + event.preventDefault = fixEvent.preventDefault; + event.stopPropagation = fixEvent.stopPropagation; + return event; +}; +fixEvent.preventDefault = function() { + this.returnValue = false; +}; +fixEvent.stopPropagation = function() { + this.cancelBubble = true; +} + +// Dean's forEach: http://dean.edwards.name/base/forEach.js +/* + forEach, version 1.0 + Copyright 2006, Dean Edwards + License: http://www.opensource.org/licenses/mit-license.php +*/ + +// array-like enumeration +if (!Array.forEach) { // mozilla already supports this + Array.forEach = function(array, block, context) { + for (var i = 0; i < array.length; i++) { + block.call(context, array[i], i, array); + } + }; +} + +// generic enumeration +Function.prototype.forEach = function(object, block, context) { + for (var key in object) { + if (typeof this.prototype[key] == "undefined") { + block.call(context, object[key], key, object); + } + } +}; + +// character enumeration +String.forEach = function(string, block, context) { + Array.forEach(string.split(""), function(chr, index) { + block.call(context, chr, index, string); + }); +}; + +// globally resolve forEach enumeration +var forEach = function(object, block, context) { + if (object) { + var resolve = Object; // default + if (object instanceof Function) { + // functions have a "length" property + resolve = Function; + } else if (object.forEach instanceof Function) { + // the object implements a custom forEach method so use that + object.forEach(block, context); + return; + } else if (typeof object == "string") { + // the object is a string + resolve = String; + } else if (typeof object.length == "number") { + // the object is array-like + resolve = Array; + } + resolve.forEach(object, block, context); + } +}; |