diff options
Diffstat (limited to 'lib/docs')
| -rw-r--r-- | lib/docs/index.html | 188 | ||||
| -rw-r--r-- | lib/docs/main.js | 3344 |
2 files changed, 2396 insertions, 1136 deletions
diff --git a/lib/docs/index.html b/lib/docs/index.html index 61e3bb4ed2..03579d975e 100644 --- a/lib/docs/index.html +++ b/lib/docs/index.html @@ -26,25 +26,23 @@ --search-sh-color: rgba(0, 0, 0, 0.18); --help-sh-color: rgba(0, 0, 0, 0.75); } - + html, body { margin: 0; padding:0; height: 100%; } a { text-decoration: none; } - + a:hover { text-decoration: underline; } - + .hidden { display: none; } /* layout */ .canvas { - display: flex; - flex-direction: column; width: 100vw; height: 100vh; overflow: hidden; @@ -55,21 +53,12 @@ background-color: var(--bg-color); } - .banner { - background-color: darkred; - text-align: center; - color: white; - padding: 15px 5px; - } - - .banner a { - color: bisque; - text-decoration: underline; - } - .flex-main { display: flex; - overflow-y: hidden; + width: 100%; + height: 100%; + justify-content: center; + z-index: 100; } @@ -87,7 +76,7 @@ overflow-wrap: break-word; flex-shrink: 0; flex-grow: 0; - + z-index: 300; } @@ -97,7 +86,7 @@ -webkit-overflow-scrolling: touch; flex-grow: 1; flex-shrink: 1; - + z-index: 200; } @@ -106,44 +95,44 @@ max-width: 85vw; flex-shrink: 1; } - + .help-modal { z-index: 400; } - + /* sidebar */ .sidebar { font-size: 1rem; background-color: var(--bg-color); box-shadow: 0 0 1rem var(--sidebar-sh-color); } - + .sidebar .logo { padding: 1rem 0.35rem 0.35rem 0.35rem; } - + .sidebar .logo > svg { display: block; overflow: visible; } - + .sidebar h2 { margin: 0.5rem; padding: 0; font-size: 1.2rem; } - + .sidebar h2 > span { border-bottom: 0.125rem dotted var(--tx-color); } - + .sidebar .packages { list-style-type: none; margin: 0; padding: 0; background-color: var(--sidebar-pkg-bg-color); } - + .sidebar .packages > li > a { display: block; padding: 0.5rem 1rem; @@ -151,17 +140,17 @@ background-color: var(--sidebar-pkglnk-bg-color); text-decoration: none; } - + .sidebar .packages > li > a:hover { color: var(--sidebar-pkglnk-tx-color-hover); background-color: var(--sidebar-pkglnk-bg-color-hover); } - + .sidebar .packages > li > a.active { color: var(--sidebar-pkglnk-tx-color-active); background-color: var(--sidebar-pkglnk-bg-color-active); } - + .sidebar p.str { margin: 0.5rem; font-family: var(--mono); @@ -194,28 +183,28 @@ border-radius: 0; -webkit-appearance: none; } - + .docs .search:focus { background-color: var(--search-bg-color-focus); border-bottom-color: #ffbb4d; box-shadow: 0 0.3em 1em 0.125em var(--search-sh-color); } - + .docs .search::placeholder { font-size: 1rem; font-family: var(--ui); color: var(--tx-color); opacity: 0.5; } - + .docs a { color: var(--link-color); } - + .docs p { margin: 0.8rem 0; } - + .docs pre { font-family: var(--mono); font-size:1em; @@ -223,19 +212,19 @@ padding:1em; overflow-x: auto; } - + .docs code { font-family: var(--mono); font-size: 1em; } - + .docs h1 { font-size: 1.4em; margin: 0.8em 0; padding: 0; border-bottom: 0.0625rem dashed; } - + .docs h2 { font-size: 1.3em; margin: 0.5em 0; @@ -275,7 +264,7 @@ #tableFnErrors dt { font-weight: bold; } - + .examples { list-style-type: none; margin: 0; @@ -286,7 +275,7 @@ white-space: nowrap; overflow-x: auto; } - + .docs td { margin: 0; padding: 0.5em; @@ -294,7 +283,7 @@ text-overflow: ellipsis; overflow-x: hidden; } - + /* help dialog */ .help-modal { display: flex; @@ -319,23 +308,23 @@ border: 0.125rem solid #000; box-shadow: 0 0.5rem 2.5rem 0.3rem var(--help-sh-color); } - + .help-modal h1 { margin: 0.75em 2.5em 1em 2.5em; font-size: 1.5em; text-align: center; } - + .help-modal dt, .help-modal dd { display: inline; margin: 0 0.2em; } - + .help-modal dl { margin-left: 0.5em; margin-right: 0.5em; } - + .help-modal kbd { display: inline-block; padding: 0.3em 0.2em; @@ -352,7 +341,14 @@ box-shadow: inset 0 -0.0625em 0 #c6cbd1; cursor: default; } - + + #listFns dt { + font-family: var(--mono); + } + .argBreaker { + display: none; + } + /* tokens */ .tok-kw { color: #333; @@ -382,10 +378,10 @@ color: #458; font-weight: bold; } - + /* dark mode */ @media (prefers-color-scheme: dark) { - + :root { --tx-color: #bbb; --bg-color: #111; @@ -403,7 +399,7 @@ --search-sh-color: rgba(255, 255, 255, 0.28); --help-sh-color: rgba(142, 142, 142, 0.5); } - + .docs pre { background-color:#2A2A2A; } @@ -451,7 +447,7 @@ .tok-type { color: #68f; } - + } @media only screen and (max-width: 750px) { @@ -523,34 +519,87 @@ min-width: calc(100% - 2.8rem); } } + .banner { + background-color: orange; + text-align: center; + color: black; + padding: 5px 5px; + } + .banner a { + color: black; + text-decoration: underline; + } </style> </head> <body class="canvas"> - <div class="banner">These docs are experimental. <a href="https://kristoff.it/blog/zig-new-relationship-llvm/">Progress depends on the self-hosted compiler</a>, <a href="https://github.com/ziglang/zig/wiki/How-to-read-the-standard-library-source-code">consider reading the stdlib source in the meantime</a>.</div> + <div class="banner"> + This is a beta autodoc build; expect bugs and missing information. + <a href="https://github.com/ziglang/zig/wiki/How-to-contribute-to-Autodoc">Report an Issue</a>, + <a href="https://github.com/ziglang/zig/wiki/How-to-contribute-to-Autodoc">Contribute</a>, + <a href="https://github.com/ziglang/zig/wiki/How-to-read-the-standard-library-source-code">Learn more about stdlib source code</a>. + </div> <div class="flex-main"> <div class="flex-filler"></div> <div class="flex-left sidebar"> <nav> <div class="logo"> - <svg version="1.1" viewBox="0 0 150 80" xmlns="http://www.w3.org/2000/svg"> - <g fill="#f7a41d"> - <path d="m0,-0.08899l0,80l19,0l6,-10l12,-10l-17,0l0,-40l15,0l0,-20l-35,0zm40,0l0,20l62,0l0,-20l-62,0zm91,0l-6,10l-12,10l17,0l0,40l-15,0l0,20l35,0l0,-80l-19,0zm-83,60l0,20l62,0l0,-20l-62,0z" shape-rendering="crispEdges"></path> - <path d="m37,59.91101l-18,20l0,-15l18,-5z"></path> - <path d="m113,19.91101l18,-20l0,15l-18,5z"></path> - <path d="m96.98,0.54101l36.28,-10.4l-80.29,89.17l-36.28,10.4l80.29,-89.17z"></path> - </g> + <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 140"> + <g fill="#F7A41D"> + <g> + <polygon points="46,22 28,44 19,30"/> + <polygon points="46,22 33,33 28,44 22,44 22,95 31,95 20,100 12,117 0,117 0,22" shape-rendering="crispEdges"/> + <polygon points="31,95 12,117 4,106"/> + </g> + <g> + <polygon points="56,22 62,36 37,44"/> + <polygon points="56,22 111,22 111,44 37,44 56,32" shape-rendering="crispEdges"/> + <polygon points="116,95 97,117 90,104"/> + <polygon points="116,95 100,104 97,117 42,117 42,95" shape-rendering="crispEdges"/> + <polygon points="150,0 52,117 3,140 101,22"/> + </g> + <g> + <polygon points="141,22 140,40 122,45"/> + <polygon points="153,22 153,117 106,117 120,105 125,95 131,95 131,45 122,45 132,36 141,22" shape-rendering="crispEdges"/> + <polygon points="125,95 130,110 106,117"/> + </g> + </g> + <style> + #text { fill: #121212 } + @media (prefers-color-scheme: dark) { #text { fill: #f2f2f2 } } + </style> + <g id="text"> + <g> + <polygon points="260,22 260,37 229,40 177,40 177,22" shape-rendering="crispEdges"/> + <polygon points="260,37 207,99 207,103 176,103 229,40 229,37"/> + <polygon points="261,99 261,117 176,117 176,103 206,99" shape-rendering="crispEdges"/> + </g> + <rect x="272" y="22" shape-rendering="crispEdges" width="22" height="95"/> + <g> + <polygon points="394,67 394,106 376,106 376,81 360,70 346,67" shape-rendering="crispEdges"/> + <polygon points="360,68 376,81 346,67"/> + <path d="M394,106c-10.2,7.3-24,12-37.7,12c-29,0-51.1-20.8-51.1-48.3c0-27.3,22.5-48.1,52-48.1 c14.3,0,29.2,5.5,38.9,14l-13,15c-7.1-6.3-16.8-10-25.9-10c-17,0-30.2,12.9-30.2,29.5c0,16.8,13.3,29.6,30.3,29.6 c5.7,0,12.8-2.3,19-5.5L394,106z"/> + </g> + </g> </svg> + </div> + <div id="sectMainPkg" class="hidden"> + <h2><span>Main Package</span></h2> + <ul class="packages"> + <li><a id="mainPkg" class="" href=""></a></li> + </ul> </div> <div id="sectPkgs" class="hidden"> - <h2><span>Packages</span></h2> + <h2><span>Dependencies</span></h2> <ul id="listPkgs" class="packages"></ul> </div> <div id="sectInfo" class="hidden"> <h2><span>Zig Version</span></h2> <p class="str" id="tdZigVer"></p> - <h2><span>Target</span></h2> - <p class="str" id="tdTarget"></p> </div> + <div> + <input id="privDeclsBox" type="checkbox"/> + <label for="privDeclsBox">Internal Doc Mode</label> + </div> </nav> </div> <div class="flex-right"> @@ -588,7 +637,6 @@ <div id="sectSearchResults" class="hidden"> <h2>Search Results</h2> <ul id="listSearchResults"></ul> - <p id="sectSearchAllResultsLink" class="hidden"><a href="">show all results</a></p> </div> <div id="sectSearchNoResults" class="hidden"> <h2>No Results Found</h2> @@ -617,9 +665,7 @@ <div id="sectFns" class="hidden"> <h2>Functions</h2> <div class="table-container"> - <table> - <tbody id="listFns"></tbody> - </table> + <dl id="listFns"></dl> </div> </div> <div id="sectValues" class="hidden"> @@ -638,7 +684,15 @@ <h2>Examples</h2> <ul id="listFnExamples" class="examples"></ul> </div> - </section> + <div id="sectTests" class="hidden"> + <h2>Tests</h2> + <div class="table-container"> + <table> + <tbody id="listTests"></tbody> + </table> + </div> + </div> + </section> </div> <div class="flex-filler"></div> </div> diff --git a/lib/docs/main.js b/lib/docs/main.js index fa209e51cf..8be263e57f 100644 --- a/lib/docs/main.js +++ b/lib/docs/main.js @@ -1,73 +1,83 @@ +'use strict'; + +var zigAnalysis; + (function() { - var domStatus = document.getElementById("status"); - var domSectNav = document.getElementById("sectNav"); - var domListNav = document.getElementById("listNav"); - var domSectPkgs = document.getElementById("sectPkgs"); - var domListPkgs = document.getElementById("listPkgs"); - var domSectTypes = document.getElementById("sectTypes"); - var domListTypes = document.getElementById("listTypes"); - var domSectNamespaces = document.getElementById("sectNamespaces"); - var domListNamespaces = document.getElementById("listNamespaces"); - var domSectErrSets = document.getElementById("sectErrSets"); - var domListErrSets = document.getElementById("listErrSets"); - var domSectFns = document.getElementById("sectFns"); - var domListFns = document.getElementById("listFns"); - var domSectFields = document.getElementById("sectFields"); - var domListFields = document.getElementById("listFields"); - var domSectGlobalVars = document.getElementById("sectGlobalVars"); - var domListGlobalVars = document.getElementById("listGlobalVars"); - var domSectValues = document.getElementById("sectValues"); - var domListValues = document.getElementById("listValues"); - var domFnProto = document.getElementById("fnProto"); - var domFnProtoCode = document.getElementById("fnProtoCode"); - var domSectParams = document.getElementById("sectParams"); - var domListParams = document.getElementById("listParams"); - var domTldDocs = document.getElementById("tldDocs"); - var domSectFnErrors = document.getElementById("sectFnErrors"); - var domListFnErrors = document.getElementById("listFnErrors"); - var domTableFnErrors = document.getElementById("tableFnErrors"); - var domFnErrorsAnyError = document.getElementById("fnErrorsAnyError"); - var domFnExamples = document.getElementById("fnExamples"); - var domListFnExamples = document.getElementById("listFnExamples"); - var domFnNoExamples = document.getElementById("fnNoExamples"); - var domDeclNoRef = document.getElementById("declNoRef"); - var domSearch = document.getElementById("search"); - var domSectSearchResults = document.getElementById("sectSearchResults"); - var domListSearchResults = document.getElementById("listSearchResults"); - var domSectSearchNoResults = document.getElementById("sectSearchNoResults"); - var domSectSearchAllResultsLink = document.getElementById("sectSearchAllResultsLink"); - var domSectInfo = document.getElementById("sectInfo"); - var domTdTarget = document.getElementById("tdTarget"); - var domTdZigVer = document.getElementById("tdZigVer"); - var domHdrName = document.getElementById("hdrName"); - var domHelpModal = document.getElementById("helpDialog"); - - var searchTimer = null; - var searchTrimResults = true; - var escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" }; - - var typeKinds = indexTypeKinds(); - var typeTypeId = findTypeTypeId(); - var pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 }; - var tokenKinds = { - Keyword: 'tok-kw', - String: 'tok-str', - Builtin: 'tok-builtin', - Comment: 'tok-comment', - Function: 'tok-fn', - Null: 'tok-null', - Number: 'tok-number', - Type: 'tok-type', - }; + let domStatus = (document.getElementById("status")); + let domSectNav = (document.getElementById("sectNav")); + let domListNav = (document.getElementById("listNav")); + let domSectMainPkg = (document.getElementById("sectMainPkg")); + let domSectPkgs = (document.getElementById("sectPkgs")); + let domListPkgs = (document.getElementById("listPkgs")); + let domSectTypes = (document.getElementById("sectTypes")); + let domListTypes = (document.getElementById("listTypes")); + let domSectTests = (document.getElementById("sectTests")); + let domListTests = (document.getElementById("listTests")); + let domSectNamespaces = (document.getElementById("sectNamespaces")); + let domListNamespaces = (document.getElementById("listNamespaces")); + let domSectErrSets = (document.getElementById("sectErrSets")); + let domListErrSets = (document.getElementById("listErrSets")); + let domSectFns = (document.getElementById("sectFns")); + let domListFns = (document.getElementById("listFns")); + let domSectFields = (document.getElementById("sectFields")); + let domListFields = (document.getElementById("listFields")); + let domSectGlobalVars = (document.getElementById("sectGlobalVars")); + let domListGlobalVars = (document.getElementById("listGlobalVars")); + let domSectValues = (document.getElementById("sectValues")); + let domListValues = (document.getElementById("listValues")); + let domFnProto = (document.getElementById("fnProto")); + let domFnProtoCode = (document.getElementById("fnProtoCode")); + let domSectParams = (document.getElementById("sectParams")); + let domListParams = (document.getElementById("listParams")); + let domTldDocs = (document.getElementById("tldDocs")); + let domSectFnErrors = (document.getElementById("sectFnErrors")); + let domListFnErrors = (document.getElementById("listFnErrors")); + let domTableFnErrors =(document.getElementById("tableFnErrors")); + let domFnErrorsAnyError = (document.getElementById("fnErrorsAnyError")); + let domFnExamples = (document.getElementById("fnExamples")); + // let domListFnExamples = (document.getElementById("listFnExamples")); + let domFnNoExamples = (document.getElementById("fnNoExamples")); + let domDeclNoRef = (document.getElementById("declNoRef")); + let domSearch = (document.getElementById("search")); + let domSectSearchResults = (document.getElementById("sectSearchResults")); + + let domListSearchResults = (document.getElementById("listSearchResults")); + let domSectSearchNoResults = (document.getElementById("sectSearchNoResults")); + let domSectInfo = (document.getElementById("sectInfo")); + // let domTdTarget = (document.getElementById("tdTarget")); + let domPrivDeclsBox = (document.getElementById("privDeclsBox")); + let domTdZigVer = (document.getElementById("tdZigVer")); + let domHdrName = (document.getElementById("hdrName")); + let domHelpModal = (document.getElementById("helpDialog")); + + + let searchTimer = null; + + + let escapeHtmlReplacements = { "&": "&", '"': """, "<": "<", ">": ">" }; + + let typeKinds = (indexTypeKinds()); + let typeTypeId = (findTypeTypeId()); + let pointerSizeEnum = { One: 0, Many: 1, Slice: 2, C: 3 }; // for each package, is an array with packages to get to this one - var canonPkgPaths = computeCanonicalPackagePaths(); + let canonPkgPaths = computeCanonicalPackagePaths(); + + + // for each decl, is an array with {declNames, pkgNames} to get to this one - var canonDeclPaths = null; // lazy; use getCanonDeclPath + + let canonDeclPaths = null; // lazy; use getCanonDeclPath + // for each type, is an array with {declNames, pkgNames} to get to this one - var canonTypeDecls = null; // lazy; use getCanonTypeDecl + + let canonTypeDecls = null; // lazy; use getCanonTypeDecl - var curNav = { + + + + let curNav = { + showPrivDecls: false, // each element is a package name, e.g. @import("a") then within there @import("b") // starting implicitly from root package pkgNames: [], @@ -82,27 +92,43 @@ // (a, b, c, d) comptime call; result is the value the docs refer to callName: null, }; - var curNavSearch = ""; - var curSearchIndex = -1; - var imFeelingLucky = false; - var rootIsStd = detectRootIsStd(); + let curNavSearch = ""; + let curSearchIndex = -1; + let imFeelingLucky = false; + + let rootIsStd = detectRootIsStd(); // map of decl index to list of non-generic fn indexes - var nodesToFnsMap = indexNodesToFns(); + // let nodesToFnsMap = indexNodesToFns(); // map of decl index to list of comptime fn calls - var nodesToCallsMap = indexNodesToCalls(); + // let nodesToCallsMap = indexNodesToCalls(); domSearch.addEventListener('keydown', onSearchKeyDown, false); - domSectSearchAllResultsLink.addEventListener('click', onClickSearchShowAllResults, false); - + domPrivDeclsBox.addEventListener('change', function() { + if (this.checked != curNav.showPrivDecls) { + if (this.checked && location.hash.length > 1 && location.hash[1] != '*'){ + location.hash = "#*" + location.hash.substring(1); + return; + } + if (!this.checked && location.hash.length > 1 && location.hash[1] == '*') { + location.hash = "#" + location.hash.substring(2); + return; + } + } + }, false); + + if (location.hash == "") { + location.hash = "#root"; + } + window.addEventListener('hashchange', onHashChange, false); window.addEventListener('keydown', onWindowKeyDown, false); onHashChange(); function renderTitle() { - var list = curNav.pkgNames.concat(curNav.declNames); - var suffix = " - Zig"; + let list = curNav.pkgNames.concat(curNav.declNames); + let suffix = " - Zig"; if (list.length === 0) { if (rootIsStd) { document.title = "std" + suffix; @@ -114,20 +140,221 @@ } } + + function isDecl(x) { + return "value" in x; + } + + + function isType(x) { + return "kind" in x && !("value" in x); + } + + + function isContainerType(x) { + return isType(x) && typeKindIsContainer((x).kind) ; + } + + + function typeShorthandName(expr) { + let resolvedExpr = resolveValue({expr: expr}); + if (!("type" in resolvedExpr)) { + return null; + } + let type = (zigAnalysis.types[resolvedExpr.type]); + + outer: for (let i = 0; i < 10000; i += 1) { + switch (type.kind) { + case typeKinds.Optional: + case typeKinds.Pointer: + let child = (type).child; + let resolvedChild = resolveValue(child); + if ("type" in resolvedChild) { + type = zigAnalysis.types[resolvedChild.type]; + continue; + } else { + return null; + } + default: + break outer; + } + + if (i == 9999) throw "Exhausted typeShorthandName quota"; + } + + + + let name = undefined; + if (type.kind === typeKinds.Struct) { + name = "struct"; + } else if (type.kind === typeKinds.Enum) { + name = "enum"; + } else if (type.kind === typeKinds.Union) { + name = "union"; + } else { + console.log("TODO: unhalndled case in typeShortName"); + return null; + } + + return escapeHtml(name); + } + + + function typeKindIsContainer(typeKind) { + return typeKind === typeKinds.Struct || + typeKind === typeKinds.Union || + typeKind === typeKinds.Enum; + } + + + function declCanRepresentTypeKind(typeKind) { + return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind); + } + + // + // function findCteInRefPath(path) { + // for (let i = path.length - 1; i >= 0; i -= 1) { + // const ref = path[i]; + // if ("string" in ref) continue; + // if ("comptimeExpr" in ref) return ref; + // if ("refPath" in ref) return findCteInRefPath(ref.refPath); + // return null; + // } + + // return null; + // } + + + function resolveValue(value) { + let i = 0; + while(i < 1000) { + i += 1; + + if ("refPath" in value.expr) { + value = {expr: value.expr.refPath[value.expr.refPath.length -1]}; + continue; + } + + if ("declRef" in value.expr) { + value = zigAnalysis.decls[value.expr.declRef].value; + continue; + } + + if ("as" in value.expr) { + value = { + typeRef: zigAnalysis.exprs[value.expr.as.typeRefArg], + expr: zigAnalysis.exprs[value.expr.as.exprArg], + }; + continue; + } + + return value; + + } + console.assert(false); + return ({}); + } + + +// function typeOfDecl(decl){ +// return decl.value.typeRef; +// +// let i = 0; +// while(i < 1000) { +// i += 1; +// console.assert(isDecl(decl)); +// if ("type" in decl.value) { +// return ({ type: typeTypeId }); +// } +// +//// if ("string" in decl.value) { +//// return ({ type: { +//// kind: typeKinds.Pointer, +//// size: pointerSizeEnum.One, +//// child: }); +//// } +// +// if ("refPath" in decl.value) { +// decl = ({ +// value: decl.value.refPath[decl.value.refPath.length -1] +// }); +// continue; +// } +// +// if ("declRef" in decl.value) { +// decl = zigAnalysis.decls[decl.value.declRef]; +// continue; +// } +// +// if ("int" in decl.value) { +// return decl.value.int.typeRef; +// } +// +// if ("float" in decl.value) { +// return decl.value.float.typeRef; +// } +// +// if ("array" in decl.value) { +// return decl.value.array.typeRef; +// } +// +// if ("struct" in decl.value) { +// return decl.value.struct.typeRef; +// } +// +// if ("comptimeExpr" in decl.value) { +// const cte = zigAnalysis.comptimeExprs[decl.value.comptimeExpr]; +// return cte.typeRef; +// } +// +// if ("call" in decl.value) { +// const fn_call = zigAnalysis.calls[decl.value.call]; +// let fn_decl = undefined; +// if ("declRef" in fn_call.func) { +// fn_decl = zigAnalysis.decls[fn_call.func.declRef]; +// } else if ("refPath" in fn_call.func) { +// console.assert("declRef" in fn_call.func.refPath[fn_call.func.refPath.length -1]); +// fn_decl = zigAnalysis.decls[fn_call.func.refPath[fn_call.func.refPath.length -1].declRef]; +// } else throw {}; +// +// const fn_decl_value = resolveValue(fn_decl.value); +// console.assert("type" in fn_decl_value); //TODO handle comptimeExpr +// const fn_type = (zigAnalysis.types[fn_decl_value.type]); +// console.assert(fn_type.kind === typeKinds.Fn); +// return fn_type.ret; +// } +// +// if ("void" in decl.value) { +// return ({ type: typeTypeId }); +// } +// +// if ("bool" in decl.value) { +// return ({ type: typeKinds.Bool }); +// } +// +// console.log("TODO: handle in `typeOfDecl` more cases: ", decl); +// console.assert(false); +// throw {}; +// } +// console.assert(false); +// return ({}); +// } + function render() { domStatus.classList.add("hidden"); domFnProto.classList.add("hidden"); domSectParams.classList.add("hidden"); domTldDocs.classList.add("hidden"); + domSectMainPkg.classList.add("hidden"); domSectPkgs.classList.add("hidden"); domSectTypes.classList.add("hidden"); + domSectTests.classList.add("hidden"); domSectNamespaces.classList.add("hidden"); domSectErrSets.classList.add("hidden"); domSectFns.classList.add("hidden"); domSectFields.classList.add("hidden"); domSectSearchResults.classList.add("hidden"); domSectSearchNoResults.classList.add("hidden"); - domSectSearchAllResultsLink.classList.add("hidden"); domSectInfo.classList.add("hidden"); domHdrName.classList.add("hidden"); domSectNav.classList.add("hidden"); @@ -144,15 +371,17 @@ renderInfo(); renderPkgList(); + domPrivDeclsBox.checked = curNav.showPrivDecls; + if (curNavSearch !== "") { return renderSearch(); } - var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; - var pkg = rootPkg; + let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; + let pkg = rootPkg; curNav.pkgObjs = [pkg]; - for (var i = 0; i < curNav.pkgNames.length; i += 1) { - var childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]]; + for (let i = 0; i < curNav.pkgNames.length; i += 1) { + let childPkg = zigAnalysis.packages[pkg.table[curNav.pkgNames[i]]]; if (childPkg == null) { return render404(); } @@ -160,52 +389,68 @@ curNav.pkgObjs.push(pkg); } - var decl = zigAnalysis.types[pkg.main]; - curNav.declObjs = [decl]; - for (var i = 0; i < curNav.declNames.length; i += 1) { - var childDecl = findSubDecl(decl, curNav.declNames[i]); + + let currentType = zigAnalysis.types[pkg.main]; + curNav.declObjs = [currentType]; + for (let i = 0; i < curNav.declNames.length; i += 1) { + + + let childDecl = findSubDecl((currentType), curNav.declNames[i]); if (childDecl == null) { return render404(); } - var container = getDeclContainerType(childDecl); - if (container == null) { - if (i + 1 === curNav.declNames.length) { - curNav.declObjs.push(childDecl); - break; - } else { - return render404(); + + let childDeclValue = resolveValue((childDecl).value).expr; + if ("type" in childDeclValue) { + + const t = zigAnalysis.types[childDeclValue.type]; + if (t.kind != typeKinds.Fn) { + childDecl = t; } } - decl = container; - curNav.declObjs.push(decl); + + currentType = (childDecl); + curNav.declObjs.push(currentType); } renderNav(); - var lastDecl = curNav.declObjs[curNav.declObjs.length - 1]; - if (lastDecl.pubDecls != null) { - renderContainer(lastDecl); - } - if (lastDecl.kind == null) { - return renderUnknownDecl(lastDecl); - } else if (lastDecl.kind === 'var') { - return renderVar(lastDecl); - } else if (lastDecl.kind === 'const' && lastDecl.type != null) { - var typeObj = zigAnalysis.types[lastDecl.type]; - if (typeObj.kind === typeKinds.Fn) { - return renderFn(lastDecl); - } else { - return renderValue(lastDecl); + let last = curNav.declObjs[curNav.declObjs.length - 1]; + let lastIsDecl = isDecl(last); + let lastIsType = isType(last); + let lastIsContainerType = isContainerType(last); + + if (lastIsContainerType) { + return renderContainer((last)); + } + + if (!lastIsDecl && !lastIsType) { + return renderUnknownDecl((last)); + } + + if (lastIsType) { + return renderType((last)); + } + + if (lastIsDecl && last.kind === 'var') { + return renderVar((last)); + } + + if (lastIsDecl && last.kind === 'const') { + let typeObj = zigAnalysis.types[resolveValue((last).value).expr.type]; + if (typeObj && typeObj.kind === typeKinds.Fn) { + return renderFn((last)); } - } else { - renderType(lastDecl); + + return renderValue((last)); } } + function renderUnknownDecl(decl) { domDeclNoRef.classList.remove("hidden"); - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { domTldDocs.innerHTML = markdown(docs); } else { @@ -214,85 +459,130 @@ domTldDocs.classList.remove("hidden"); } + function typeIsErrSet(typeIndex) { - var typeObj = zigAnalysis.types[typeIndex]; + let typeObj = zigAnalysis.types[typeIndex]; return typeObj.kind === typeKinds.ErrorSet; } + function typeIsStructWithNoFields(typeIndex) { - var typeObj = zigAnalysis.types[typeIndex]; + let typeObj = zigAnalysis.types[typeIndex]; if (typeObj.kind !== typeKinds.Struct) return false; - return typeObj.fields == null || typeObj.fields.length === 0; + return (typeObj).fields.length == 0; } + function typeIsGenericFn(typeIndex) { - var typeObj = zigAnalysis.types[typeIndex]; + let typeObj = zigAnalysis.types[typeIndex]; if (typeObj.kind !== typeKinds.Fn) { return false; } - return typeObj.generic; + return (typeObj).generic_ret != null; } + function renderFn(fnDecl) { - domFnProtoCode.innerHTML = typeIndexName(fnDecl.type, true, true, fnDecl); + if ("refPath" in fnDecl.value.expr) { + let last = fnDecl.value.expr.refPath.length - 1; + let lastExpr = fnDecl.value.expr.refPath[last]; + console.assert("declRef" in lastExpr); + fnDecl = zigAnalysis.decls[lastExpr.declRef]; + } - var docsSource = null; - var srcNode = zigAnalysis.astNodes[fnDecl.src]; + let value = resolveValue(fnDecl.value); + console.assert("type" in value.expr); + let typeObj = (zigAnalysis.types[value.expr.type]); + + domFnProtoCode.innerHTML = exprName(value.expr, { + wantHtml: true, + wantLink: true, + fnDecl, + }); + + let docsSource = null; + let srcNode = zigAnalysis.astNodes[fnDecl.src]; if (srcNode.docs != null) { docsSource = srcNode.docs; } - var typeObj = zigAnalysis.types[fnDecl.type]; renderFnParamDocs(fnDecl, typeObj); - var errSetTypeIndex = null; - if (typeObj.ret != null) { - var retType = zigAnalysis.types[typeObj.ret]; + let retExpr = resolveValue({expr:typeObj.ret}).expr; + if ("type" in retExpr) { + let retIndex = retExpr.type; + let errSetTypeIndex = (null); + let retType = zigAnalysis.types[retIndex]; if (retType.kind === typeKinds.ErrorSet) { - errSetTypeIndex = typeObj.ret; + errSetTypeIndex = retIndex; } else if (retType.kind === typeKinds.ErrorUnion) { - errSetTypeIndex = retType.err; + errSetTypeIndex = (retType).err.type; + } + if (errSetTypeIndex != null) { + let errSetType = (zigAnalysis.types[errSetTypeIndex]); + renderErrorSet(errSetType); } } - if (errSetTypeIndex != null) { - var errSetType = zigAnalysis.types[errSetTypeIndex]; - renderErrorSet(errSetType); - } - - var fnObj = zigAnalysis.fns[fnDecl.value]; - var protoSrcIndex = fnObj.src; - if (typeIsGenericFn(fnDecl.type)) { - var instantiations = nodesToFnsMap[protoSrcIndex]; - var calls = nodesToCallsMap[protoSrcIndex]; - if (instantiations == null && calls == null) { - domFnNoExamples.classList.remove("hidden"); - } else if (calls != null) { - if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls); - if (fnObj.combined != null) { - renderContainer(fnObj.combined, calls.map(function (call) { return zigAnalysis.calls[call].result.value })); - } - var domListFnExamplesFragment = createDomListFragment(calls.length, '<li></li>'); + let protoSrcIndex = fnDecl.src; + if (typeIsGenericFn(value.expr.type)) { + // does the generic_ret contain a container? + var resolvedGenericRet = resolveValue({expr: typeObj.generic_ret}); + + if ("call" in resolvedGenericRet.expr){ + let call = zigAnalysis.calls[resolvedGenericRet.expr.call]; + let resolvedFunc = resolveValue({expr: call.func}); + if (!("type" in resolvedFunc.expr)) return; + let callee = zigAnalysis.types[resolvedFunc.expr.type]; + if (!callee.generic_ret) return; + resolvedGenericRet = resolveValue({expr: callee.generic_ret}); + } - for (var callI = 0; callI < calls.length; callI += 1) { - var liDom = domListFnExamplesFragment.children[callI]; - liDom.innerHTML = getCallHtml(fnDecl, calls[callI]); - } + // TODO: see if unwrapping the `as` here is a good idea or not. + if ("as" in resolvedGenericRet.expr) { + resolvedGenericRet = { + expr: zigAnalysis.exprs[resolvedGenericRet.expr.as.exprArg] + }; + } - domListFnExamples.innerHTML = ""; - domListFnExamples.appendChild(domListFnExamplesFragment); - domFnExamples.classList.remove("hidden"); - } else if (instantiations != null) { - // TODO + if (!("type" in resolvedGenericRet.expr)) return; + const genericType = zigAnalysis.types[resolvedGenericRet.expr.type]; + if (isContainerType(genericType)) { + renderContainer(genericType) } + + + + + + // old code + // let instantiations = nodesToFnsMap[protoSrcIndex]; + // let calls = nodesToCallsMap[protoSrcIndex]; + // if (instantiations == null && calls == null) { + // domFnNoExamples.classList.remove("hidden"); + // } else if (calls != null) { + // // if (fnObj.combined === undefined) fnObj.combined = allCompTimeFnCallsResult(calls); + // if (fnObj.combined != null) renderContainer(fnObj.combined); + + // resizeDomList(domListFnExamples, calls.length, '<li></li>'); + + // for (let callI = 0; callI < calls.length; callI += 1) { + // let liDom = domListFnExamples.children[callI]; + // liDom.innerHTML = getCallHtml(fnDecl, calls[callI]); + // } + + // domFnExamples.classList.remove("hidden"); + // } else if (instantiations != null) { + // // TODO + // } } else { domFnExamples.classList.add("hidden"); domFnNoExamples.classList.add("hidden"); } - var protoSrcNode = zigAnalysis.astNodes[protoSrcIndex]; + let protoSrcNode = zigAnalysis.astNodes[protoSrcIndex]; if (docsSource == null && protoSrcNode != null && protoSrcNode.docs != null) { docsSource = protoSrcNode.docs; } @@ -303,17 +593,17 @@ domFnProto.classList.remove("hidden"); } + function renderFnParamDocs(fnDecl, typeObj) { - var docCount = 0; + let docCount = 0; - var fnObj = zigAnalysis.fns[fnDecl.value]; - var fnNode = zigAnalysis.astNodes[fnObj.src]; - var fields = fnNode.fields; - var isVarArgs = fnNode.varArgs; + let fnNode = zigAnalysis.astNodes[fnDecl.src]; + let fields = (fnNode.fields); + let isVarArgs = fnNode.varArgs; - for (var i = 0; i < fields.length; i += 1) { - var field = fields[i]; - var fieldNode = zigAnalysis.astNodes[field]; + for (let i = 0; i < fields.length; i += 1) { + let field = fields[i]; + let fieldNode = zigAnalysis.astNodes[field]; if (fieldNode.docs != null) { docCount += 1; } @@ -322,56 +612,55 @@ return; } - var domListParamsFragment = createDomListFragment(docCount, '<div></div>'); - var domIndex = 0; + resizeDomList(domListParams, docCount, '<div></div>'); + let domIndex = 0; - for (var i = 0; i < fields.length; i += 1) { - var field = fields[i]; - var fieldNode = zigAnalysis.astNodes[field]; + for (let i = 0; i < fields.length; i += 1) { + let field = fields[i]; + let fieldNode = zigAnalysis.astNodes[field]; if (fieldNode.docs == null) { continue; } - var divDom = domListParamsFragment.children[domIndex]; + let divDom = domListParams.children[domIndex]; domIndex += 1; - var argTypeIndex = typeObj.args[i]; - var html = '<pre>' + escapeHtml(fieldNode.name) + ": "; - if (isVarArgs && i === typeObj.args.length - 1) { + + let value = typeObj.params[i]; + let html = '<pre>' + escapeHtml((fieldNode.name)) + ": "; + if (isVarArgs && i === typeObj.params.length - 1) { html += '...'; - } else if (argTypeIndex != null) { - html += typeIndexName(argTypeIndex, true, true); } else { - html += '<span class="tok-kw">var</span>'; + let name = exprName(value, {wantHtml: false, wantLink: false}); + html += '<span class="tok-kw">' + name + '</span>'; } html += ',</pre>'; - var docs = fieldNode.docs; + let docs = fieldNode.docs; if (docs != null) { html += markdown(docs); } divDom.innerHTML = html; } - - domListParams.innerHTML = ""; - domListParams.appendChild(domListParamsFragment); domSectParams.classList.remove("hidden"); } function renderNav() { - var len = curNav.pkgNames.length + curNav.declNames.length; - var domListNavFragment = createDomListFragment(len, '<li><a href="#"></a></li>'); - var list = []; - var hrefPkgNames = []; - var hrefDeclNames = []; - for (var i = 0; i < curNav.pkgNames.length; i += 1) { + let len = curNav.pkgNames.length + curNav.declNames.length; + resizeDomList(domListNav, len, '<li><a href="#"></a></li>'); + let list = []; + let hrefPkgNames = []; + let hrefDeclNames = ([]); + for (let i = 0; i < curNav.pkgNames.length; i += 1) { hrefPkgNames.push(curNav.pkgNames[i]); + let name = curNav.pkgNames[i]; + if (name == "root") name = zigAnalysis.rootPkgName; list.push({ - name: curNav.pkgNames[i], + name: name, link: navLink(hrefPkgNames, hrefDeclNames), }); } - for (var i = 0; i < curNav.declNames.length; i += 1) { + for (let i = 0; i < curNav.declNames.length; i += 1) { hrefDeclNames.push(curNav.declNames[i]); list.push({ name: curNav.declNames[i], @@ -379,9 +668,9 @@ }); } - for (var i = 0; i < list.length; i += 1) { - var liDom = domListNavFragment.children[i]; - var aDom = liDom.children[0]; + for (let i = 0; i < list.length; i += 1) { + let liDom = domListNav.children[i]; + let aDom = liDom.children[0]; aDom.textContent = list[i].name; aDom.setAttribute('href', list[i].link); if (i + 1 == list.length) { @@ -391,14 +680,12 @@ } } - domListNav.innerHTML = ""; - domListNav.appendChild(domListNavFragment); domSectNav.classList.remove("hidden"); } function renderInfo() { domTdZigVer.textContent = zigAnalysis.params.zigVersion; - domTdTarget.textContent = zigAnalysis.params.builds[0].target; + //domTdTarget.textContent = zigAnalysis.params.builds[0].target; domSectInfo.classList.remove("hidden"); } @@ -409,26 +696,39 @@ } function renderPkgList() { - var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; - var list = []; - for (var key in rootPkg.table) { - if (key === "root" && rootIsStd) continue; - var pkgIndex = rootPkg.table[key]; + let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; + let list = []; + for (let key in rootPkg.table) { + let pkgIndex = rootPkg.table[key]; if (zigAnalysis.packages[pkgIndex] == null) continue; + if (key == zigAnalysis.params.rootName) continue; list.push({ name: key, pkg: pkgIndex, }); } + + { + let aDom = domSectMainPkg.children[1].children[0].children[0]; + aDom.textContent = zigAnalysis.rootPkgName; + aDom.setAttribute('href', navLinkPkg(zigAnalysis.rootPkg)); + if (zigAnalysis.params.rootName === curNav.pkgNames[0]) { + aDom.classList.add("active"); + } else { + aDom.classList.remove("active"); + } + domSectMainPkg.classList.remove("hidden"); + } + list.sort(function(a, b) { return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase()); }); if (list.length !== 0) { - var domListPkgsFragment = createDomListFragment(list.length, '<li><a href="#"></a></li>'); - for (var i = 0; i < list.length; i += 1) { - var liDom = domListPkgsFragment.children[i]; - var aDom = liDom.children[0]; + resizeDomList(domListPkgs, list.length, '<li><a href="#"></a></li>'); + for (let i = 0; i < list.length; i += 1) { + let liDom = domListPkgs.children[i]; + let aDom = liDom.children[0]; aDom.textContent = list[i].name; aDom.setAttribute('href', navLinkPkg(list[i].pkg)); if (list[i].name === curNav.pkgNames[0]) { @@ -438,488 +738,1338 @@ } } - domListPkgs.innerHTML = ""; - domListPkgs.appendChild(domListPkgsFragment); domSectPkgs.classList.remove("hidden"); } } + + function navLink(pkgNames, declNames, callName) { + let base = '#'; + if (curNav.showPrivDecls) { + base += "*"; + } + if (pkgNames.length === 0 && declNames.length === 0) { - return '#'; + return base; } else if (declNames.length === 0 && callName == null) { - return '#' + pkgNames.join('.'); + return base + pkgNames.join('.'); } else if (callName == null) { - return '#' + pkgNames.join('.') + ';' + declNames.join('.'); + return base + pkgNames.join('.') + ';' + declNames.join('.'); } else { - return '#' + pkgNames.join('.') + ';' + declNames.join('.') + ';' + callName; + return base + pkgNames.join('.') + ';' + declNames.join('.') + ';' + callName; } } + function navLinkPkg(pkgIndex) { return navLink(canonPkgPaths[pkgIndex], []); } + function navLinkDecl(childName) { return navLink(curNav.pkgNames, curNav.declNames.concat([childName])); } - function navLinkCall(callObj) { - var declNamesCopy = curNav.declNames.concat([]); - var callName = declNamesCopy.pop(); - - callName += '('; - for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) { - if (arg_i !== 0) callName += ','; - var argObj = callObj.args[arg_i]; - callName += getValueText(argObj.type, argObj.value, false, false); - } - callName += ')'; - - declNamesCopy.push(callName); - return navLink(curNav.pkgNames, declNamesCopy); - } - - function createDomListFragment(desiredLen, templateHtml) { - var domTemplate = document.createElement("template"); - domTemplate.innerHTML = templateHtml.repeat(desiredLen); - return domTemplate.content; - } - - function typeIndexName(typeIndex, wantHtml, wantLink, fnDecl, linkFnNameDecl, thisTypes) { - if(thisTypes && thisTypes.includes(typeIndex)){ - return token('@This', tokenKinds.Builtin, wantHtml) + '()'; - } - var typeObj = zigAnalysis.types[typeIndex]; - var declNameOk = declCanRepresentTypeKind(typeObj.kind); - if (wantLink) { - var declIndex = getCanonTypeDecl(typeIndex); - var declPath = getCanonDeclPath(declIndex); - if (declPath == null) { - return typeName(typeObj, wantHtml, wantLink, fnDecl, linkFnNameDecl, thisTypes); - } - var name = (wantLink && declCanRepresentTypeKind(typeObj.kind)) ? - declPath.declNames[declPath.declNames.length - 1] : - typeName(typeObj, wantHtml, false, fnDecl, linkFnNameDecl, thisTypes); - if (wantLink && wantHtml) { - return '<a href="' + navLink(declPath.pkgNames, declPath.declNames) + '">' + name + '</a>'; + // + // function navLinkCall(callObj) { + // let declNamesCopy = curNav.declNames.concat([]); + // let callName = (declNamesCopy.pop()); + + // callName += '('; + // for (let arg_i = 0; arg_i < callObj.args.length; arg_i += 1) { + // if (arg_i !== 0) callName += ','; + // let argObj = callObj.args[arg_i]; + // callName += getValueText(argObj, argObj, false, false); + // } + // callName += ')'; + + // declNamesCopy.push(callName); + // return navLink(curNav.pkgNames, declNamesCopy); + // } + + + function resizeDomListDl(dlDom, desiredLen) { + // add the missing dom entries + for (let i = dlDom.childElementCount / 2; i < desiredLen; i += 1) { + dlDom.insertAdjacentHTML('beforeend', '<dt></dt><dd></dd>'); + } + // remove extra dom entries + while (desiredLen < dlDom.childElementCount / 2) { + dlDom.removeChild(dlDom.lastChild); + dlDom.removeChild(dlDom.lastChild); + } + } + + + function resizeDomList(listDom, desiredLen, templateHtml) { + // add the missing dom entries + for (let i = listDom.childElementCount; i < desiredLen; i += 1) { + listDom.insertAdjacentHTML('beforeend', templateHtml); + } + // remove extra dom entries + while (desiredLen < listDom.childElementCount) { + listDom.removeChild(listDom.lastChild); + } + } + + function walkResultTypeRef(wr) { + if (wr.typeRef) return wr.typeRef; + let resolved = resolveValue(wr); + if (wr === resolved) { + return {type: 0}; + } + return walkResultTypeRef(resolved); + } + + function exprName(expr, opts) { + switch (Object.keys(expr)[0]) { + default: throw "oh no"; + case "&": { + return "&" + exprName(zigAnalysis.exprs[expr["&"]]); + } + case "compileError": { + let compileError = expr.compileError; + return compileError; + } + case "enumLiteral": { + let literal = expr.enumLiteral; + return "." + literal; + } + case "void": { + return "void"; + } + case "slice":{ + let payloadHtml = ""; + const lhsExpr = zigAnalysis.exprs[expr.slice.lhs]; + const startExpr = zigAnalysis.exprs[expr.slice.start]; + let decl = exprName(lhsExpr); + let start = exprName(startExpr); + let end = ""; + let sentinel = ""; + if (expr.slice['end']) { + const endExpr = zigAnalysis.exprs[expr.slice.end]; + let end_ = exprName(endExpr); + end += end_; + } + if (expr.slice['sentinel']) { + const sentinelExpr = zigAnalysis.exprs[expr.slice.sentinel]; + let sentinel_ = exprName(sentinelExpr); + sentinel += " :" + sentinel_; + } + payloadHtml += decl + "["+ start + ".." + end + sentinel + "]"; + return payloadHtml; + } + case "sliceIndex": { + const sliceIndex = zigAnalysis.exprs[expr.sliceIndex]; + return exprName(sliceIndex, opts); + } + case "cmpxchg":{ + const typeIndex = zigAnalysis.exprs[expr.cmpxchg.type]; + const ptrIndex = zigAnalysis.exprs[expr.cmpxchg.ptr]; + const expectedValueIndex = zigAnalysis.exprs[expr.cmpxchg.expected_value]; + const newValueIndex = zigAnalysis.exprs[expr.cmpxchg.new_value]; + const successOrderIndex = zigAnalysis.exprs[expr.cmpxchg.success_order]; + const failureOrderIndex = zigAnalysis.exprs[expr.cmpxchg.failure_order]; + + const type = exprName(typeIndex, opts); + const ptr = exprName(ptrIndex, opts); + const expectedValue = exprName(expectedValueIndex, opts); + const newValue = exprName(newValueIndex, opts); + const successOrder = exprName(successOrderIndex, opts); + const failureOrder = exprName(failureOrderIndex, opts); + + let fnName = "@"; + + switch (expr.cmpxchg.name) { + case "cmpxchg_strong": { + fnName += "cmpxchgStrong" + break; + } + case "cmpxchg_weak": { + fnName += "cmpxchgWeak" + break; + } + default: { + console.log("There's only cmpxchg_strong and cmpxchg_weak"); + } + } + + return fnName + "(" + type + ", " + ptr + ", " + expectedValue + ", "+ newValue + ", "+"." +successOrder + ", "+ "." +failureOrder + ")"; + } + case "cmpxchgIndex": { + const cmpxchgIndex = zigAnalysis.exprs[expr.cmpxchgIndex]; + return exprName(cmpxchgIndex, opts); + } + case "switchOp":{ + let condExpr = zigAnalysis.exprs[expr.switchOp.cond_index]; + let ast = zigAnalysis.astNodes[expr.switchOp.ast]; + let file_name = expr.switchOp.file_name; + let outer_decl_index = expr.switchOp.outer_decl; + let outer_decl = zigAnalysis.types[outer_decl_index]; + let line = 0; + // console.log(expr.switchOp) + // console.log(outer_decl) + while (outer_decl_index !== 0 && outer_decl.line_number > 0) { + line += outer_decl.line_number; + outer_decl_index = outer_decl.outer_decl; + outer_decl = zigAnalysis.types[outer_decl_index]; + // console.log(outer_decl) + } + line += ast.line + 1; + let payloadHtml = ""; + let cond = exprName(condExpr, opts); + + payloadHtml += "</br>" + "node_name: " + ast.name + "</br>" + "file: " + file_name + "</br>" + "line: " + line + "</br>"; + payloadHtml += "switch(" + cond + ") {" + "<a href=\"https://github.com/ziglang/zig/tree/master/lib/std/" + file_name + "#L" + line + "\">" +"..." + "</a>}"; + return payloadHtml; + } + case "switchIndex": { + const switchIndex = zigAnalysis.exprs[expr.switchIndex]; + return exprName(switchIndex, opts); + } + case "refPath" : { + const declRef = expr.refPath[0].declRef; + let name = zigAnalysis.decls[declRef].name; + for (let i = 1; i < expr.refPath.length; i++) { + let component = undefined; + if ("string" in expr.refPath[i]) { + component = expr.refPath[i].string; + } else { + component = exprName(expr.refPath[i]); + } + name += "." + component; + } + return name; + } + case "fieldRef" : { + const enumObj = exprName({"type":expr.fieldRef.type} ,opts); + const field = zigAnalysis.astNodes[enumObj.ast].fields[expr.fieldRef.index]; + const name = zigAnalysis.astNodes[field].name; + return name + } + case "enumToInt" : { + const enumToInt = zigAnalysis.exprs[expr.enumToInt]; + return "@enumToInt(" + exprName(enumToInt, opts) + ")"; + } + case "bitSizeOf" : { + const bitSizeOf = zigAnalysis.exprs[expr.bitSizeOf]; + return "@bitSizeOf(" + exprName(bitSizeOf, opts) + ")"; + } + case "sizeOf" : { + const sizeOf = zigAnalysis.exprs[expr.sizeOf]; + return "@sizeOf(" + exprName(sizeOf, opts) + ")"; + } + case "builtinIndex" : { + const builtinIndex = zigAnalysis.exprs[expr.builtinIndex]; + return exprName(builtinIndex, opts); + } + case "builtin": { + const param_expr = zigAnalysis.exprs[expr.builtin.param]; + let param = exprName(param_expr, opts); + + + let payloadHtml = "@"; + switch (expr.builtin.name) { + case "align_of": { + payloadHtml += "alignOf"; + break; + } + case "bool_to_int": { + payloadHtml += "boolToInt"; + break; + } + case "embed_file": { + payloadHtml += "embedFile"; + break; + } + case "error_name": { + payloadHtml += "errorName"; + break; + } + case "panic": { + payloadHtml += "panic"; + break; + } + case "set_cold": { + payloadHtml += "setCold"; + break; + } + case "set_runtime_safety": { + payloadHtml += "setRuntimeSafety"; + break; + } + case "sqrt": { + payloadHtml += "sqrt"; + break; + } + case "sin": { + payloadHtml += "sin"; + break; + } + case "cos": { + payloadHtml += "cos"; + break; + } + case "tan": { + payloadHtml += "tan"; + break; + } + case "exp": { + payloadHtml += "exp"; + break; + } + case "exp2": { + payloadHtml += "exp2"; + break; + } + case "log": { + payloadHtml += "log"; + break; + } + case "log2": { + payloadHtml += "log2"; + break; + } + case "log10": { + payloadHtml += "log10"; + break; + } + case "fabs": { + payloadHtml += "fabs"; + break; + } + case "floor": { + payloadHtml += "floor"; + break; + } + case "ceil": { + payloadHtml += "ceil"; + break; + } + case "trunc": { + payloadHtml += "trunc"; + break; + } + case "round": { + payloadHtml += "round"; + break; + } + case "tag_name": { + payloadHtml += "tagName"; + break; + } + case "reify": { + payloadHtml += "Type"; + break; + } + case "type_name": { + payloadHtml += "typeName"; + break; + } + case "frame_type": { + payloadHtml += "Frame"; + break; + } + case "frame_size": { + payloadHtml += "frameSize"; + break; + } + case "ptr_to_int": { + payloadHtml += "ptrToInt"; + break; + } + case "error_to_int": { + payloadHtml += "errorToInt"; + break; + } + case "int_to_error": { + payloadHtml += "intToError"; + break; + } + case "maximum": { + payloadHtml += "maximum"; + break; + } + case "minimum": { + payloadHtml += "minimum"; + break; + } + case "bit_not": { + return "~" + param; + } + case "clz": { + return "@clz(T" + ", " + param + ")"; + } + case "ctz": { + return "@ctz(T" + ", " + param + ")"; + } + case "pop_count": { + return "@popCount(T" + ", " + param + ")"; + } + case "byte_swap": { + return "@byteSwap(T" + ", " + param + ")"; + } + case "bit_reverse": { + return "@bitReverse(T" + ", " + param + ")"; + } + default: console.log("builtin function not handled yet or doesn't exist!"); + }; + return payloadHtml + "(" + param + ")"; + + } + case "builtinBinIndex" : { + const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex]; + return exprName(builtinBinIndex, opts); + } + case "builtinBin": { + const lhsOp = zigAnalysis.exprs[expr.builtinBin.lhs]; + const rhsOp = zigAnalysis.exprs[expr.builtinBin.rhs]; + let lhs = exprName(lhsOp, opts); + let rhs = exprName(rhsOp, opts); + + let payloadHtml = "@"; + switch (expr.builtinBin.name) { + case "float_to_int": { + payloadHtml += "floatToInt"; + break; + } + case "int_to_float": { + payloadHtml += "intToFloat"; + break; + } + case "int_to_ptr": { + payloadHtml += "intToPtr"; + break; + } + case "int_to_enum": { + payloadHtml += "intToEnum"; + break; + } + case "float_cast": { + payloadHtml += "floatCast"; + break; + } + case "int_cast": { + payloadHtml += "intCast"; + break; + } + case "ptr_cast": { + payloadHtml += "ptrCast"; + break; + } + case "truncate": { + payloadHtml += "truncate"; + break; + } + case "align_cast": { + payloadHtml += "alignCast"; + break; + } + case "has_decl": { + payloadHtml += "hasDecl"; + break; + } + case "has_field": { + payloadHtml += "hasField"; + break; + } + case "bit_reverse": { + payloadHtml += "bitReverse"; + break; + } + case "div_exact": { + payloadHtml += "divExact"; + break; + } + case "div_floor": { + payloadHtml += "divFloor"; + break; + } + case "div_trunc": { + payloadHtml += "divTrunc"; + break; + } + case "mod": { + payloadHtml += "mod"; + break; + } + case "rem": { + payloadHtml += "rem"; + break; + } + case "mod_rem": { + payloadHtml += "rem"; + break; + } + case "shl_exact": { + payloadHtml += "shlExact"; + break; + } + case "shr_exact": { + payloadHtml += "shrExact"; + break; + } + case "bitcast" : { + payloadHtml += "bitCast"; + break; + } + case "align_cast" : { + payloadHtml += "alignCast"; + break; + } + case "vector_type" : { + payloadHtml += "Vector"; + break; + } + case "reduce": { + payloadHtml += "reduce"; + break; + } + case "splat": { + payloadHtml += "splat"; + break; + } + case "offset_of": { + payloadHtml += "offsetOf"; + break; + } + case "bit_offset_of": { + payloadHtml += "bitOffsetOf"; + break; + } + default: console.log("builtin function not handled yet or doesn't exist!"); + }; + return payloadHtml + "(" + lhs + ", " + rhs + ")"; + + } + case "binOpIndex" : { + const binOpIndex = zigAnalysis.exprs[expr.binOpIndex]; + return exprName(binOpIndex, opts); + } + case "binOp": { + const lhsOp = zigAnalysis.exprs[expr.binOp.lhs]; + const rhsOp = zigAnalysis.exprs[expr.binOp.rhs]; + let lhs = exprName(lhsOp, opts); + let rhs = exprName(rhsOp, opts); + + let print_lhs = ""; + let print_rhs = ""; + + if (lhsOp['binOpIndex']) { + print_lhs = "(" + lhs + ")"; } else { - return name; + print_lhs = lhs; + } + if (rhsOp['binOpIndex']) { + print_rhs = "(" + rhs + ")"; + } else { + print_rhs = rhs; } - } else { - return typeName(typeObj, wantHtml, false, fnDecl, linkFnNameDecl, thisTypes); - } - } - - function shouldSkipParamName(typeIndex, paramName) { - var typeObj = zigAnalysis.types[typeIndex]; - if (typeObj.kind === typeKinds.Pointer && getPtrSize(typeObj) === pointerSizeEnum.One) { - typeIndex = typeObj.elem; - } - return typeIndexName(typeIndex, false, true).toLowerCase() === paramName; - } - - function getPtrSize(typeObj) { - return (typeObj.len == null) ? pointerSizeEnum.One : typeObj.len; - } - - function getCallHtml(fnDecl, callIndex) { - var callObj = zigAnalysis.calls[callIndex]; - - // TODO make these links work - //var html = '<a href="' + navLinkCall(callObj) + '">' + escapeHtml(fnDecl.name) + '</a>('; - var html = escapeHtml(fnDecl.name) + '('; - for (var arg_i = 0; arg_i < callObj.args.length; arg_i += 1) { - if (arg_i !== 0) html += ', '; - var argObj = callObj.args[arg_i]; - html += getValueText(argObj.type, argObj.value, true, true); - } - html += ')'; - return html; - } - function getValueText(typeIndex, value, wantHtml, wantLink) { - var typeObj = zigAnalysis.types[typeIndex]; - switch (typeObj.kind) { - case typeKinds.Type: - return typeIndexName(value, wantHtml, wantLink); - case typeKinds.Fn: - var fnObj = zigAnalysis.fns[value]; - var declPath = fnObj.decl && getCanonDeclPath(fnObj.decl); - var fnName = declPath ? declPath.declNames.join('.') : '(unknown)'; - - if (!wantHtml) { - return fnName; - } + let operator = ""; - var str = '<span class="tok-fn">'; - if (wantLink && declPath != null) { - str += '<a href="' + navLink(declPath.pkgNames, declPath.declNames) + '">'; - str += escapeHtml(fnName); - str += '</a>'; - } else { - str += escapeHtml(fnName); - } - str += '</span>'; - return str; - case typeKinds.Int: - return token(value, tokenKinds.Number, wantHtml); - case typeKinds.Optional: - if(value === 'null'){ - return token(value, tokenKinds.Null, wantHtml); - } else { - console.trace("TODO non-null optional value printing"); - return "TODO"; - } - case typeKinds.Bool: - return token(value, tokenKinds.Null, wantHtml); - default: - console.trace("TODO implement getValueText for this type:", zigAnalysis.typeKinds[typeObj.kind]); - return "TODO"; - } - } + switch (expr.binOp.name) { + case "add": { + operator += "+"; + break; + } + case "addwrap": { + operator += "+%"; + break; + } + case "add_sat": { + operator += "+|"; + break; + } + case "sub": { + operator += "-"; + break; + } + case "subwrap": { + operator += "-%"; + break; + } + case "sub_sat": { + operator += "-|"; + break; + } + case "mul": { + operator += "*"; + break; + } + case "mulwrap": { + operator += "*%"; + break; + } + case "mul_sat": { + operator += "*|"; + break; + } + case "div": { + operator += "/"; + break; + } + case "shl": { + operator += "<<"; + break; + } + case "shl_sat": { + operator += "<<|"; + break; + } + case "shr": { + operator += ">>"; + break; + } + case "bit_or" : { + operator += "|"; + break; + } + case "bit_and" : { + operator += "&"; + break; + } + case "array_cat" : { + operator += "++"; + break; + } + case "array_mul" : { + operator += "**"; + break; + } + default: console.log("operator not handled yet or doesn't exist!"); + }; - function typeName(typeObj, wantHtml, wantSubLink, fnDecl, linkFnNameDecl, thisTypes) { - switch (typeObj.kind) { - case typeKinds.Array: - var name = "["; - name += token(typeObj.len, tokenKinds.Number, wantHtml); - name += "]"; - name += typeIndexName(typeObj.elem, wantHtml, wantSubLink, null, null, thisTypes); - return name; - case typeKinds.Vector: - var name = "Vector("; - name += token(typeObj.len, tokenKinds.Number, wantHtml); - name += ", "; - name += typeIndexName(typeObj.elem, wantHtml, wantSubLink, null, null, thisTypes); - name += ")"; - return name; - case typeKinds.Optional: - return "?" + typeIndexName(typeObj.child, wantHtml, wantSubLink, fnDecl, linkFnNameDecl, thisTypes); - case typeKinds.Pointer: - var name = ""; - switch (typeObj.len) { - case pointerSizeEnum.One: - default: - name += "*"; - break; - case pointerSizeEnum.Many: - name += "[*]"; - break; - case pointerSizeEnum.Slice: - name += "[]"; - break; - case pointerSizeEnum.C: - name += "[*c]"; - break; - } - if (typeObj['const']) { - name += token('const', tokenKinds.Keyword, wantHtml) + ' '; - } - if (typeObj['volatile']) { - name += token('volatile', tokenKinds.Keyword, wantHtml) + ' '; - } - if (typeObj.align != null) { - name += token('align', tokenKinds.Keyword, wantHtml) + '('; - name += token(typeObj.align, tokenKinds.Number, wantHtml); - - if (typeObj.hostIntBytes != null) { - name += ":"; - name += token(typeObj.bitOffsetInHost, tokenKinds.Number, wantHtml); - name += ":"; - name += token(typeObj.hostIntBytes, tokenKinds.Number, wantHtml); - } - name += ") "; + return print_lhs + " " + operator + " " + print_rhs; + + } + case "errorSets": { + const errUnionObj = zigAnalysis.types[expr.errorSets]; + let lhs = exprName(errUnionObj.lhs, opts); + let rhs = exprName(errUnionObj.rhs, opts); + return lhs + " || " + rhs; + + } + case "errorUnion": { + const errUnionObj = zigAnalysis.types[expr.errorUnion]; + let lhs = exprName(errUnionObj.lhs, opts); + let rhs = exprName(errUnionObj.rhs, opts); + return lhs + "!" + rhs; + + } + case "struct": { + const struct_name = zigAnalysis.decls[expr.struct[0].val.typeRef.refPath[0].declRef].name; + let struct_body = ""; + struct_body += struct_name + "{ "; + for (let i = 0; i < expr.struct.length; i++) { + const val = expr.struct[i].name + const exprArg = zigAnalysis.exprs[expr.struct[i].val.expr.as.exprArg]; + let value_field = exprArg[Object.keys(exprArg)[0]]; + if (value_field instanceof Object) { + value_field = zigAnalysis.decls[value_field[0].val.typeRef.refPath[0].declRef].name; + }; + struct_body += "." + val + " = " + value_field; + if (i !== expr.struct.length - 1) { + struct_body += ", "; + } else { + struct_body += " "; + } + } + struct_body += "}"; + return struct_body; + } + case "typeOf_peer": { + let payloadHtml = "@TypeOf(" + for (let i = 0; i < expr.typeOf_peer.length; i++) { + let elem = zigAnalysis.exprs[expr.typeOf_peer[i]]; + payloadHtml += exprName(elem, {wantHtml: true, wantLink:true}); + if (i !== expr.typeOf_peer.length - 1) { + payloadHtml += ", "; + } + } + payloadHtml += ")"; + return payloadHtml; + + } + case "alignOf": { + const alignRefArg = zigAnalysis.exprs[expr.alignOf]; + let payloadHtml = "@alignOf(" + exprName(alignRefArg, {wantHtml: true, wantLink:true}) + ")"; + return payloadHtml; + } + case "typeOf": { + const typeRefArg = zigAnalysis.exprs[expr.typeOf]; + let payloadHtml = "@TypeOf(" + exprName(typeRefArg, {wantHtml: true, wantLink:true}) + ")"; + return payloadHtml; + } + case "null": { + return "null"; + } + case "array": { + let payloadHtml = ".{"; + for (let i = 0; i < expr.array.length; i++) { + if (i != 0) payloadHtml += ", "; + let elem = zigAnalysis.exprs[expr.array[i]]; + payloadHtml += exprName(elem, opts); + } + return payloadHtml + "}"; + } + case "comptimeExpr": { + return zigAnalysis.comptimeExprs[expr.comptimeExpr].code; + } + case "call": { + let call = zigAnalysis.calls[expr.call]; + let payloadHtml = ""; + + + switch(Object.keys(call.func)[0]){ + default: throw "TODO"; + case "declRef": + case "refPath": { + payloadHtml += exprName(call.func, opts); + break; } - name += typeIndexName(typeObj.elem, wantHtml, wantSubLink, null, null, thisTypes); - return name; - case typeKinds.Float: - return token('f' + typeObj.bits, tokenKinds.Type, wantHtml); - case typeKinds.Int: - var signed = (typeObj.i != null) ? 'i' : 'u'; - var bits = typeObj[signed]; - return token(signed + bits, tokenKinds.Type, wantHtml); - case typeKinds.ComptimeInt: - return token('comptime_int', tokenKinds.Type, wantHtml); - case typeKinds.ComptimeFloat: - return token('comptime_float', tokenKinds.Type, wantHtml); - case typeKinds.Type: - return token('type', tokenKinds.Type, wantHtml); - case typeKinds.Bool: - return token('bool', tokenKinds.Type, wantHtml); - case typeKinds.Void: - return token('void', tokenKinds.Type, wantHtml); - case typeKinds.EnumLiteral: - return token('(enum literal)', tokenKinds.Type, wantHtml); - case typeKinds.NoReturn: - return token('noreturn', tokenKinds.Type, wantHtml); - case typeKinds.ErrorSet: - if (typeObj.errors == null) { - return token('anyerror', tokenKinds.Type, wantHtml); - } else { - if (wantHtml) { - return escapeHtml(typeObj.name); + } + payloadHtml += "("; + + for (let i = 0; i < call.args.length; i++) { + if (i != 0) payloadHtml += ", "; + payloadHtml += exprName(call.args[i], opts); + } + + payloadHtml += ")"; + return payloadHtml; + } + case "as": { + // @Check : this should be done in backend because there are legit @as() calls + // const typeRefArg = zigAnalysis.exprs[expr.as.typeRefArg]; + const exprArg = zigAnalysis.exprs[expr.as.exprArg]; + // return "@as(" + exprName(typeRefArg, opts) + + // ", " + exprName(exprArg, opts) + ")"; + return exprName(exprArg, opts); + } + case "declRef": { + return zigAnalysis.decls[expr.declRef].name; + } + case "refPath": { + return expr.refPath.map(x => exprName(x, opts)).join("."); + } + case "int": { + return "" + expr.int; + } + case "float": { + return "" + expr.float.toFixed(2); + } + case "float128": { + return "" + expr.float128.toFixed(2); + } + case "undefined": { + return "undefined"; + } + case "string": { + return "\"" + escapeHtml(expr.string) + "\""; + } + + case "anytype": { + return "anytype"; + } + + case "this":{ + return "@This()"; + } + + case "type": { + let name = ""; + + let typeObj = expr.type; + if (typeof typeObj === 'number') typeObj = zigAnalysis.types[typeObj]; + switch (typeObj.kind) { + default: throw "TODO"; + case typeKinds.Struct: + { + let structObj = (typeObj); + return structObj; + } + case typeKinds.Enum: + { + let enumObj = (typeObj); + return enumObj; + } + case typeKinds.Opaque: + { + let opaqueObj = (typeObj); + + return opaqueObj.name; + } + case typeKinds.ComptimeExpr: + { + return "anyopaque"; + } + case typeKinds.Array: + { + let arrayObj = typeObj; + let name = "["; + let lenName = exprName(arrayObj.len, opts); + let sentinel = arrayObj.sentinel ? ":"+exprName(arrayObj.sentinel, opts) : ""; + // let is_mutable = arrayObj.is_multable ? "const " : ""; + + if (opts.wantHtml) { + name += + '<span class="tok-number">' + lenName + sentinel + "</span>"; } else { - return typeObj.name; + name += lenName + sentinel; } - } - case typeKinds.ErrorUnion: - var errSetTypeObj = zigAnalysis.types[typeObj.err]; - var payloadHtml = typeIndexName(typeObj.payload, wantHtml, wantSubLink, null, null, thisTypes); - if (fnDecl != null && errSetTypeObj.fn === fnDecl.value) { - // function index parameter supplied and this is the inferred error set of it - return "!" + payloadHtml; - } else { - return typeIndexName(typeObj.err, wantHtml, wantSubLink, null, null, thisTypes) + "!" + payloadHtml; - } - case typeKinds.Fn: - var payloadHtml = ""; - if (wantHtml) { - payloadHtml += '<span class="tok-kw">fn</span>'; - if (fnDecl != null) { - payloadHtml += ' <span class="tok-fn">'; - if (linkFnNameDecl != null) { - payloadHtml += '<a href="' + linkFnNameDecl + '">' + - escapeHtml(fnDecl.name) + '</a>'; - } else { - payloadHtml += escapeHtml(fnDecl.name); - } - payloadHtml += '</span>'; - } - } else { - payloadHtml += 'fn' - } - payloadHtml += '('; - if (typeObj.args != null) { - var fields = null; - var isVarArgs = false; - if (fnDecl != null) { - var fnObj = zigAnalysis.fns[fnDecl.value]; - var fnNode = zigAnalysis.astNodes[fnObj.src]; - fields = fnNode.fields; - isVarArgs = fnNode.varArgs; + name += "]"; + // name += is_mutable; + name += exprName(arrayObj.child, opts); + return name; + } + case typeKinds.Optional: + return "?" + exprName((typeObj).child, opts); + case typeKinds.Pointer: + { + let ptrObj = (typeObj); + let sentinel = ptrObj.sentinel ? ":"+exprName(ptrObj.sentinel, opts) : ""; + let is_mutable = !ptrObj.is_mutable ? "const " : ""; + let name = ""; + switch (ptrObj.size) { + default: + console.log("TODO: implement unhandled pointer size case"); + case pointerSizeEnum.One: + name += "*"; + name += is_mutable; + break; + case pointerSizeEnum.Many: + name += "[*"; + name += sentinel; + name += "]"; + name += is_mutable; + break; + case pointerSizeEnum.Slice: + if (ptrObj.is_ref) { + name += "*"; + } + name += "["; + name += sentinel; + name += "]"; + name += is_mutable; + break; + case pointerSizeEnum.C: + name += "[*c"; + name += sentinel; + name += "]"; + name += is_mutable; + break; + } + // @check: after the major changes in arrays the consts are came from switch above + // if (!ptrObj.is_mutable) { + // if (opts.wantHtml) { + // name += '<span class="tok-kw">const</span> '; + // } else { + // name += "const "; + // } + // } + if (ptrObj.is_allowzero) { + name += "allowzero "; + } + if (ptrObj.is_volatile) { + name += "volatile "; + } + if (ptrObj.has_addrspace) { + name += "addrspace("; + name += "." + ""; + name += ") "; + } + if (ptrObj.has_align) { + let align = exprName(ptrObj.align, opts); + if (opts.wantHtml) { + name += '<span class="tok-kw">align</span>('; + } else { + name += "align("; + } + if (opts.wantHtml) { + name += '<span class="tok-number">' + align + '</span>'; + } else { + name += align; + } + if (ptrObj.hostIntBytes != null) { + name += ":"; + if (opts.wantHtml) { + name += '<span class="tok-number">' + ptrObj.bitOffsetInHost + '</span>'; + } else { + name += ptrObj.bitOffsetInHost; + } + name += ":"; + if (opts.wantHtml) { + name += '<span class="tok-number">' + ptrObj.hostIntBytes + '</span>'; + } else { + name += ptrObj.hostIntBytes; + } + } + name += ") "; + } + //name += typeValueName(ptrObj.child, wantHtml, wantSubLink, null); + name += exprName(ptrObj.child, opts); + return name; + } + case typeKinds.Float: + { + let floatObj = (typeObj); + + if (opts.wantHtml) { + return '<span class="tok-type">' + floatObj.name + '</span>'; + } else { + return floatObj.name; + } + } + case typeKinds.Int: + { + let intObj = (typeObj); + let name = intObj.name; + if (opts.wantHtml) { + return '<span class="tok-type">' + name + '</span>'; + } else { + return name; + } + } + case typeKinds.ComptimeInt: + if (opts.wantHtml) { + return '<span class="tok-type">comptime_int</span>'; + } else { + return "comptime_int"; + } + case typeKinds.ComptimeFloat: + if (opts.wantHtml) { + return '<span class="tok-type">comptime_float</span>'; + } else { + return "comptime_float"; + } + case typeKinds.Type: + if (opts.wantHtml) { + return '<span class="tok-type">type</span>'; + } else { + return "type"; + } + case typeKinds.Bool: + if (opts.wantHtml) { + return '<span class="tok-type">bool</span>'; + } else { + return "bool"; + } + case typeKinds.Void: + if (opts.wantHtml) { + return '<span class="tok-type">void</span>'; + } else { + return "void"; + } + case typeKinds.EnumLiteral: + if (opts.wantHtml) { + return '<span class="tok-type">(enum literal)</span>'; + } else { + return "(enum literal)"; + } + case typeKinds.NoReturn: + if (opts.wantHtml) { + return '<span class="tok-type">noreturn</span>'; + } else { + return "noreturn"; + } + case typeKinds.ErrorSet: + { + let errSetObj = (typeObj); + if (errSetObj.fields == null) { + return '<span class="tok-type">anyerror</span>'; + } else { + // throw "TODO"; + let html = "error{" + errSetObj.fields[0].name + "}"; + return html; + } + } + + case typeKinds.ErrorUnion: + { + let errUnionObj = (typeObj); + let lhs = exprName(errUnionObj.lhs, opts); + let rhs = exprName(errUnionObj.rhs, opts); + return lhs + "!" + rhs; + } + case typeKinds.Fn: + { + let fnObj = (typeObj); + let payloadHtml = ""; + if (opts.wantHtml) { + if (fnObj.is_extern) { + payloadHtml += "pub extern "; + } + if (fnObj.has_lib_name) { + payloadHtml += "\"" + fnObj.lib_name +"\" "; + } + payloadHtml += '<span class="tok-kw">fn</span>'; + if (opts.fnDecl) { + payloadHtml += ' <span class="tok-fn">'; + if (opts.linkFnNameDecl) { + payloadHtml += '<a href="' + opts.linkFnNameDecl + '">' + + escapeHtml(opts.fnDecl.name) + '</a>'; + } else { + payloadHtml += escapeHtml(opts.fnDecl.name); + } + payloadHtml += '</span>'; + } + } else { + payloadHtml += 'fn '; + } + payloadHtml += '('; + if (fnObj.params) { + let fields = null; + let isVarArgs = false; + let fnNode = zigAnalysis.astNodes[fnObj.src]; + fields = fnNode.fields; + isVarArgs = fnNode.varArgs; + + for (let i = 0; i < fnObj.params.length; i += 1) { + if (i != 0) { + payloadHtml += ', '; + } + + payloadHtml += "<span class='argBreaker'><br> </span>" + let value = fnObj.params[i]; + let paramValue = resolveValue({expr: value}); + + if (fields != null) { + let paramNode = zigAnalysis.astNodes[fields[i]]; + + if (paramNode.varArgs) { + payloadHtml += '...'; + continue; + } + + if (paramNode.noalias) { + if (opts.wantHtml) { + payloadHtml += '<span class="tok-kw">noalias</span> '; + } else { + payloadHtml += 'noalias '; + } + } + + if (paramNode.comptime) { + if (opts.wantHtml) { + payloadHtml += '<span class="tok-kw">comptime</span> '; + } else { + payloadHtml += 'comptime '; + } + } + + let paramName = paramNode.name; + if (paramName != null) { + // skip if it matches the type name + if (!shouldSkipParamName(paramValue, paramName)) { + payloadHtml += paramName + ': '; + } + } + } + + if (isVarArgs && i === fnObj.params.length - 1) { + payloadHtml += '...'; + } + else if ("alignOf" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + + } + else if ("typeOf" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + + } + else if ("typeOf_peer" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + + } + else if ("declRef" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + + } + else if ("call" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + } + else if ("refPath" in value) { + if (opts.wantHtml) { + payloadHtml += '<a href="">'; + payloadHtml += + '<span class="tok-kw" style="color:lightblue;">' + + exprName(value, opts) + '</span>'; + payloadHtml += '</a>'; + } else { + payloadHtml += exprName(value, opts); + } + } else if ("type" in value) { + let name = exprName(value, { + wantHtml: false, + wantLink: false, + fnDecl: opts.fnDecl, + linkFnNameDecl: opts.linkFnNameDecl, + }); + payloadHtml += '<span class="tok-kw">' + name + '</span>'; + } else if ("binOpIndex" in value) { + payloadHtml += exprName(value, opts); + }else if ("comptimeExpr" in value) { + let comptimeExpr = zigAnalysis.comptimeExprs[value.comptimeExpr].code; + if (opts.wantHtml) { + payloadHtml += '<span class="tok-kw">' + comptimeExpr + '</span>'; + } else { + payloadHtml += comptimeExpr; + } + } else if (opts.wantHtml) { + payloadHtml += '<span class="tok-kw">anytype</span>'; + } else { + payloadHtml += 'anytype'; + } + } + } + + payloadHtml += "<span class='argBreaker'>,<br></span>" + payloadHtml += ') '; + + if (fnObj.has_align) { + let align = zigAnalysis.exprs[fnObj.align] + payloadHtml += "align(" + exprName(align, opts) + ") "; } - - for (var i = 0; i < typeObj.args.length; i += 1) { - if (i != 0) { - payloadHtml += ', '; - } - - var argTypeIndex = typeObj.args[i]; - - if (fields != null) { - var paramNode = zigAnalysis.astNodes[fields[i]]; - - if (paramNode.varArgs) { - payloadHtml += '...'; - continue; - } - - if (paramNode.noalias) { - payloadHtml += token('noalias', tokenKinds.Keyword, wantHtml) + ' '; - } - - if (paramNode.comptime) { - payloadHtml += token('comptime', tokenKinds.Keyword, wantHtml) + ' '; - } - - var paramName = paramNode.name; - if (paramName != null) { - // skip if it matches the type name - if (argTypeIndex == null || !shouldSkipParamName(argTypeIndex, paramName)) { - payloadHtml += paramName + ': '; - } - } - } - - if (isVarArgs && i === typeObj.args.length - 1) { - payloadHtml += '...'; - } else if (argTypeIndex != null) { - payloadHtml += typeIndexName(argTypeIndex, wantHtml, wantSubLink, null, null, thisTypes); - } else { - payloadHtml += token('anytype', tokenKinds.Keyword, wantHtml); - } + if (fnObj.has_cc) { + let cc = zigAnalysis.exprs[fnObj.cc] + if (cc) { + payloadHtml += "callconv(." + cc.enumLiteral + ") "; + } } - } - payloadHtml += ') '; - if (typeObj.ret != null) { - payloadHtml += typeIndexName(typeObj.ret, wantHtml, wantSubLink, fnDecl, null, thisTypes); - } else { - payloadHtml += token('anytype', tokenKinds.Keyword, wantHtml); - } - return payloadHtml; - case typeKinds.Frame: - var fnObj = zigAnalysis.fns[typeObj.fn]; - return '@Frame(' + getValueText(fnObj.type, typeObj.fn, wantHtml, wantSubLink) + ')'; - case typeKinds.AnyFrame: - var name = token('anyframe', tokenKinds.Keyword, wantHtml); - if (typeObj.result) { - name += "->"; - name += typeIndexName(typeObj.result, wantHtml, wantSubLink, null, null, thisTypes); - } - return name; - default: - if (wantHtml) { - return escapeHtml(typeObj.name); - } else { - return typeObj.name; + if (fnObj.is_inferred_error) { + payloadHtml += "!"; + } + if (fnObj.ret != null) { + payloadHtml += exprName(fnObj.ret, opts); + } else if (opts.wantHtml) { + payloadHtml += '<span class="tok-kw">anytype</span>'; + } else { + payloadHtml += 'anytype'; + } + return payloadHtml; + } + // if (wantHtml) { + // return escapeHtml(typeObj.name); + // } else { + // return typeObj.name; + // } + } + } + + } + } + + + + function shouldSkipParamName(typeRef, paramName) { + let resolvedTypeRef = resolveValue({expr: typeRef}); + if ("type" in resolvedTypeRef) { + let typeObj = zigAnalysis.types[resolvedTypeRef.type]; + if (typeObj.kind === typeKinds.Pointer){ + let ptrObj = (typeObj); + if (getPtrSize(ptrObj) === pointerSizeEnum.One) { + const value = resolveValue(ptrObj.child); + return typeValueName(value, false, true).toLowerCase() === paramName; } + } } + return false; + } + + + function getPtrSize(typeObj) { + return (typeObj.size == null) ? pointerSizeEnum.One : typeObj.size; } + function renderType(typeObj) { - var name; + let name; if (rootIsStd && typeObj === zigAnalysis.types[zigAnalysis.packages[zigAnalysis.rootPkg].main]) { name = "std"; } else { - name = typeName(typeObj, false, false); + name = exprName({type:typeObj}, false, false); } if (name != null && name != "") { domHdrName.innerText = name + " (" + zigAnalysis.typeKinds[typeObj.kind] + ")"; domHdrName.classList.remove("hidden"); } if (typeObj.kind == typeKinds.ErrorSet) { - renderErrorSet(typeObj); + renderErrorSet((typeObj)); } } + function renderErrorSet(errSetType) { - if (errSetType.errors == null) { + if (errSetType.fields == null) { domFnErrorsAnyError.classList.remove("hidden"); } else { - var errorList = []; - for (var i = 0; i < errSetType.errors.length; i += 1) { - var errObj = zigAnalysis.errors[errSetType.errors[i]]; - var srcObj = zigAnalysis.astNodes[errObj.src]; - errorList.push({ - err: errObj, - docs: srcObj.docs, - }); + let errorList = []; + for (let i = 0; i < errSetType.fields.length; i += 1) { + let errObj = errSetType.fields[i]; + //let srcObj = zigAnalysis.astNodes[errObj.src]; + errorList.push(errObj); } errorList.sort(function(a, b) { - return operatorCompare(a.err.name.toLowerCase(), b.err.name.toLowerCase()); + return operatorCompare(a.name.toLowerCase(), b.name.toLowerCase()); }); - var domListFnErrorsFragment = createDomListFragment(errorList.length, "<dt></dt><dd></dd>"); - for (var i = 0; i < errorList.length; i += 1) { - var nameTdDom = domListFnErrorsFragment.children[i * 2 + 0]; - var descTdDom = domListFnErrorsFragment.children[i * 2 + 1]; - nameTdDom.textContent = errorList[i].err.name; - var docs = errorList[i].docs; + resizeDomListDl(domListFnErrors, errorList.length); + for (let i = 0; i < errorList.length; i += 1) { + let nameTdDom = domListFnErrors.children[i * 2 + 0]; + let descTdDom = domListFnErrors.children[i * 2 + 1]; + nameTdDom.textContent = errorList[i].name; + let docs = errorList[i].docs; if (docs != null) { descTdDom.innerHTML = markdown(docs); } else { descTdDom.textContent = ""; } } - domListFnErrors.innerHTML = ""; - domListFnErrors.appendChild(domListFnErrorsFragment); domTableFnErrors.classList.remove("hidden"); } domSectFnErrors.classList.remove("hidden"); } - function allCompTimeFnCallsHaveTypeResult(typeIndex, value) { - var srcIndex = zigAnalysis.fns[value].src; - var calls = nodesToCallsMap[srcIndex]; - if (calls == null) return false; - for (var i = 0; i < calls.length; i += 1) { - var call = zigAnalysis.calls[calls[i]]; - if (call.result.type !== typeTypeId) return false; - } - return true; - } - - function allCompTimeFnCallsResult(calls) { - var firstTypeObj = null; - var containerObj = { - privDecls: [], - }; - for (var callI = 0; callI < calls.length; callI += 1) { - var call = zigAnalysis.calls[calls[callI]]; - if (call.result.type !== typeTypeId) return null; - var typeObj = zigAnalysis.types[call.result.value]; - if (!typeKindIsContainer(typeObj.kind)) return null; - if (firstTypeObj == null) { - firstTypeObj = typeObj; - containerObj.src = typeObj.src; - } else if (firstTypeObj.src !== typeObj.src) { - return null; - } - - if (containerObj.fields == null) { - containerObj.fields = (typeObj.fields || []).concat([]); - } else for (var fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) { - var prev = containerObj.fields[fieldI]; - var next = typeObj.fields[fieldI]; - if (prev === next) continue; - if (typeof(prev) === 'object') { - if (prev[next] == null) prev[next] = typeObj; - } else { - containerObj.fields[fieldI] = {}; - containerObj.fields[fieldI][prev] = firstTypeObj; - containerObj.fields[fieldI][next] = typeObj; - } - } - - if (containerObj.pubDecls == null) { - containerObj.pubDecls = (typeObj.pubDecls || []).concat([]); - } else for (var declI = 0; declI < typeObj.pubDecls.length; declI += 1) { - var prev = containerObj.pubDecls[declI]; - var next = typeObj.pubDecls[declI]; - if (prev === next) continue; - // TODO instead of showing "examples" as the public declarations, - // do logic like this: - //if (typeof(prev) !== 'object') { - // var newDeclId = zigAnalysis.decls.length; - // prev = clone(zigAnalysis.decls[prev]); - // prev.id = newDeclId; - // zigAnalysis.decls.push(prev); - // containerObj.pubDecls[declI] = prev; - //} - //mergeDecls(prev, next, firstTypeObj, typeObj); - } - } - for (var declI = 0; declI < containerObj.pubDecls.length; declI += 1) { - var decl = containerObj.pubDecls[declI]; - if (typeof(decl) === 'object') { - containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id; - } - } - return containerObj; - } - - function mergeDecls(declObj, nextDeclIndex, firstTypeObj, typeObj) { - var nextDeclObj = zigAnalysis.decls[nextDeclIndex]; - if (declObj.type != null && nextDeclObj.type != null && declObj.type !== nextDeclObj.type) { - if (typeof(declObj.type) !== 'object') { - var prevType = declObj.type; - declObj.type = {}; - declObj.type[prevType] = firstTypeObj; - declObj.value = null; - } - declObj.type[nextDeclObj.type] = typeObj; - } else if (declObj.type == null && nextDeclObj != null) { - declObj.type = nextDeclObj.type; - } - if (declObj.value != null && nextDeclObj.value != null && declObj.value !== nextDeclObj.value) { - if (typeof(declObj.value) !== 'object') { - var prevValue = declObj.value; - declObj.value = {}; - declObj.value[prevValue] = firstTypeObj; - } - declObj.value[nextDeclObj.value] = typeObj; - } else if (declObj.value == null && nextDeclObj.value != null) { - declObj.value = nextDeclObj.value; - } - } - +// function allCompTimeFnCallsHaveTypeResult(typeIndex, value) { +// let srcIndex = zigAnalysis.fns[value].src; +// let calls = nodesToCallsMap[srcIndex]; +// if (calls == null) return false; +// for (let i = 0; i < calls.length; i += 1) { +// let call = zigAnalysis.calls[calls[i]]; +// if (call.result.type !== typeTypeId) return false; +// } +// return true; +// } +// +// function allCompTimeFnCallsResult(calls) { +// let firstTypeObj = null; +// let containerObj = { +// privDecls: [], +// }; +// for (let callI = 0; callI < calls.length; callI += 1) { +// let call = zigAnalysis.calls[calls[callI]]; +// if (call.result.type !== typeTypeId) return null; +// let typeObj = zigAnalysis.types[call.result.value]; +// if (!typeKindIsContainer(typeObj.kind)) return null; +// if (firstTypeObj == null) { +// firstTypeObj = typeObj; +// containerObj.src = typeObj.src; +// } else if (firstTypeObj.src !== typeObj.src) { +// return null; +// } +// +// if (containerObj.fields == null) { +// containerObj.fields = (typeObj.fields || []).concat([]); +// } else for (let fieldI = 0; fieldI < typeObj.fields.length; fieldI += 1) { +// let prev = containerObj.fields[fieldI]; +// let next = typeObj.fields[fieldI]; +// if (prev === next) continue; +// if (typeof(prev) === 'object') { +// if (prev[next] == null) prev[next] = typeObj; +// } else { +// containerObj.fields[fieldI] = {}; +// containerObj.fields[fieldI][prev] = firstTypeObj; +// containerObj.fields[fieldI][next] = typeObj; +// } +// } +// +// if (containerObj.pubDecls == null) { +// containerObj.pubDecls = (typeObj.pubDecls || []).concat([]); +// } else for (let declI = 0; declI < typeObj.pubDecls.length; declI += 1) { +// let prev = containerObj.pubDecls[declI]; +// let next = typeObj.pubDecls[declI]; +// if (prev === next) continue; +// // TODO instead of showing "examples" as the public declarations, +// // do logic like this: +// //if (typeof(prev) !== 'object') { +// // let newDeclId = zigAnalysis.decls.length; +// // prev = clone(zigAnalysis.decls[prev]); +// // prev.id = newDeclId; +// // zigAnalysis.decls.push(prev); +// // containerObj.pubDecls[declI] = prev; +// //} +// //mergeDecls(prev, next, firstTypeObj, typeObj); +// } +// } +// for (let declI = 0; declI < containerObj.pubDecls.length; declI += 1) { +// let decl = containerObj.pubDecls[declI]; +// if (typeof(decl) === 'object') { +// containerObj.pubDecls[declI] = containerObj.pubDecls[declI].id; +// } +// } +// return containerObj; +// } + + + + function renderValue(decl) { + let resolvedValue = resolveValue(decl.value) + + if (resolvedValue.expr.fieldRef) { + const declRef = decl.value.expr.refPath[0].declRef; + const type = zigAnalysis.decls[declRef]; + domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' + + escapeHtml(decl.name) + ': ' + type.name + + " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";"; + } else if (resolvedValue.expr.string !== undefined || resolvedValue.expr.call !== undefined || resolvedValue.expr.comptimeExpr) { + domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' + + escapeHtml(decl.name) + ': ' + exprName(resolvedValue.expr, {wantHtml: true, wantLink:true}) + + " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";"; + } else if (resolvedValue.expr.compileError) { + domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' + + escapeHtml(decl.name) + " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";"; + } + else { domFnProtoCode.innerHTML = '<span class="tok-kw">const</span> ' + - escapeHtml(decl.name) + ': ' + typeIndexName(decl.type, true, true); + escapeHtml(decl.name) + ': ' + exprName(resolvedValue.typeRef, {wantHtml: true, wantLink:true}) + + " = " + exprName(decl.value.expr, {wantHtml: true, wantLink:true}) + ";"; + } - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { domTldDocs.innerHTML = markdown(docs); domTldDocs.classList.remove("hidden"); @@ -928,11 +2078,13 @@ domFnProto.classList.remove("hidden"); } + function renderVar(decl) { + let declTypeRef = typeOfDecl(decl); domFnProtoCode.innerHTML = '<span class="tok-kw">var</span> ' + - escapeHtml(decl.name) + ': ' + typeIndexName(decl.type, true, true); + escapeHtml(decl.name) + ': ' + typeValueName(declTypeRef, true, true); - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { domTldDocs.innerHTML = markdown(docs); domTldDocs.classList.remove("hidden"); @@ -941,52 +2093,103 @@ domFnProto.classList.remove("hidden"); } - function renderContainer(container, thisTypes) { - var typesList = []; - var namespacesList = []; - var errSetsList = []; - var fnsList = []; - var varsList = []; - var valsList = []; - for (var i = 0; i < container.pubDecls.length; i += 1) { - var decl = zigAnalysis.decls[container.pubDecls[i]]; + + function categorizeDecls(decls, + typesList, namespacesList, errSetsList, + fnsList, varsList, valsList, testsList) { + + for (let i = 0; i < decls.length; i += 1) { + let decl = zigAnalysis.decls[decls[i]]; + let declValue = resolveValue(decl.value); + + if (decl.isTest) { + testsList.push(decl); + continue; + } if (decl.kind === 'var') { varsList.push(decl); continue; - } else if (decl.kind === 'const' && decl.type != null) { - if (decl.type === typeTypeId) { - if (typeIsErrSet(decl.value)) { - errSetsList.push(decl); - } else if (typeIsStructWithNoFields(decl.value)) { - namespacesList.push(decl); - } else { - typesList.push(decl); - } - } else { - var typeKind = zigAnalysis.types[decl.type].kind; - if (typeKind === typeKinds.Fn) { - if (allCompTimeFnCallsHaveTypeResult(decl.type, decl.value)) { - typesList.push(decl); + } + + if (decl.kind === 'const') { + if ("type" in declValue.expr) { + // We have the actual type expression at hand. + const typeExpr = zigAnalysis.types[declValue.expr.type]; + if (typeExpr.kind == typeKinds.Fn) { + const funcRetExpr = resolveValue({ + expr: (typeExpr).ret + }); + if ("type" in funcRetExpr.expr && funcRetExpr.expr.type == typeTypeId) { + if (typeIsErrSet(declValue.expr.type)) { + errSetsList.push(decl); + } else if (typeIsStructWithNoFields(declValue.expr.type)) { + namespacesList.push(decl); + } else { + typesList.push(decl); + } } else { fnsList.push(decl); } } else { - valsList.push(decl); + if (typeIsErrSet(declValue.expr.type)) { + errSetsList.push(decl); + } else if (typeIsStructWithNoFields(declValue.expr.type)) { + namespacesList.push(decl); + } else { + typesList.push(decl); + } } + } else if ("typeRef" in declValue) { + if ("type" in declValue.typeRef && declValue.typeRef == typeTypeId) { + // We don't know what the type expression is, but we know it's a type. + typesList.push(decl); + } else { + valsList.push(decl); + } + } else { + valsList.push(decl); } } } + } + + + function renderContainer(container) { + + let typesList = []; + + let namespacesList = []; + + let errSetsList = []; + + let fnsList = []; + + let varsList = []; + + let valsList = []; + + let testsList = []; + + categorizeDecls(container.pubDecls, + typesList, namespacesList, errSetsList, + fnsList, varsList, valsList, testsList); + if (curNav.showPrivDecls) categorizeDecls(container.privDecls, + typesList, namespacesList, errSetsList, + fnsList, varsList, valsList, testsList); + + typesList.sort(byNameProperty); namespacesList.sort(byNameProperty); errSetsList.sort(byNameProperty); fnsList.sort(byNameProperty); varsList.sort(byNameProperty); valsList.sort(byNameProperty); + testsList.sort(byNameProperty); if (container.src != null) { - var docs = zigAnalysis.astNodes[container.src].docs; + let docs = zigAnalysis.astNodes[container.src].docs; if (docs != null) { domTldDocs.innerHTML = markdown(docs); domTldDocs.classList.remove("hidden"); @@ -994,163 +2197,193 @@ } if (typesList.length !== 0) { - var domListTypesFragment = createDomListFragment(typesList.length, '<li><a href="#"></a></li>'); - for (var i = 0; i < typesList.length; i += 1) { - var liDom = domListTypesFragment.children[i]; - var aDom = liDom.children[0]; - var decl = typesList[i]; + resizeDomList(domListTypes, typesList.length, '<li><a href="#"></a></li>'); + for (let i = 0; i < typesList.length; i += 1) { + let liDom = domListTypes.children[i]; + let aDom = liDom.children[0]; + let decl = typesList[i]; aDom.textContent = decl.name; aDom.setAttribute('href', navLinkDecl(decl.name)); } - domListTypes.innerHTML = ""; - domListTypes.appendChild(domListTypesFragment); domSectTypes.classList.remove("hidden"); } if (namespacesList.length !== 0) { - var domListNamespacesFragment = createDomListFragment(namespacesList.length, '<li><a href="#"></a></li>'); - for (var i = 0; i < namespacesList.length; i += 1) { - var liDom = domListNamespacesFragment.children[i]; - var aDom = liDom.children[0]; - var decl = namespacesList[i]; + resizeDomList(domListNamespaces, namespacesList.length, '<li><a href="#"></a></li>'); + for (let i = 0; i < namespacesList.length; i += 1) { + let liDom = domListNamespaces.children[i]; + let aDom = liDom.children[0]; + let decl = namespacesList[i]; aDom.textContent = decl.name; aDom.setAttribute('href', navLinkDecl(decl.name)); } - domListNamespaces.innerHTML = ""; - domListNamespaces.appendChild(domListNamespacesFragment); domSectNamespaces.classList.remove("hidden"); } if (errSetsList.length !== 0) { - var domListErrSetsFragment = createDomListFragment(errSetsList.length, '<li><a href="#"></a></li>'); - for (var i = 0; i < errSetsList.length; i += 1) { - var liDom = domListErrSetsFragment.children[i]; - var aDom = liDom.children[0]; - var decl = errSetsList[i]; + resizeDomList(domListErrSets, errSetsList.length, '<li><a href="#"></a></li>'); + for (let i = 0; i < errSetsList.length; i += 1) { + let liDom = domListErrSets.children[i]; + let aDom = liDom.children[0]; + let decl = errSetsList[i]; aDom.textContent = decl.name; aDom.setAttribute('href', navLinkDecl(decl.name)); } - domListErrSets.innerHTML = ""; - domListErrSets.appendChild(domListErrSetsFragment); domSectErrSets.classList.remove("hidden"); } if (fnsList.length !== 0) { - var domListFnsFragment = createDomListFragment(fnsList.length, '<tr><td></td><td></td></tr>'); - for (var i = 0; i < fnsList.length; i += 1) { - var decl = fnsList[i]; - var trDom = domListFnsFragment.children[i]; + resizeDomList(domListFns, fnsList.length, '<div><dt></dt><dd></dd></div>'); + + window.x = domListFns; + for (let i = 0; i < fnsList.length; i += 1) { + let decl = fnsList[i]; + let trDom = domListFns.children[i]; + + let tdFnCode = trDom.children[0]; + let tdDesc = trDom.children[1]; - var tdFnCode = trDom.children[0]; - var tdDesc = trDom.children[1]; + let declType = resolveValue(decl.value); + console.assert("type" in declType.expr); - tdFnCode.innerHTML = typeIndexName(decl.type, true, true, decl, navLinkDecl(decl.name), thisTypes); + tdFnCode.innerHTML = exprName(declType.expr,{ + wantHtml: true, + wantLink: true, + fnDecl: decl, + linkFnNameDecl: navLinkDecl(decl.name), + }); - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { tdDesc.innerHTML = shortDescMarkdown(docs); } else { tdDesc.textContent = ""; } } - domListFns.innerHTML = ""; - domListFns.appendChild(domListFnsFragment); domSectFns.classList.remove("hidden"); } - if (container.fields != null && container.fields.length !== 0) { - var domListFieldsFragment = createDomListFragment(container.fields.length, '<div></div>'); + let containerNode = zigAnalysis.astNodes[container.src]; + if (containerNode.fields && containerNode.fields.length > 0) { + resizeDomList(domListFields, containerNode.fields.length, '<div></div>'); - var containerNode = zigAnalysis.astNodes[container.src]; - for (var i = 0; i < container.fields.length; i += 1) { - var field = container.fields[i]; - var fieldNode = zigAnalysis.astNodes[containerNode.fields[i]]; - var divDom = domListFieldsFragment.children[i]; + for (let i = 0; i < containerNode.fields.length; i += 1) { + let fieldNode = zigAnalysis.astNodes[containerNode.fields[i]]; + let divDom = domListFields.children[i]; + let fieldName = (fieldNode.name); - var html = '<div class="mobile-scroll-container"><pre class="scroll-item">' + escapeHtml(fieldNode.name); + let html = '<div class="mobile-scroll-container"><pre class="scroll-item">' + escapeHtml(fieldName); if (container.kind === typeKinds.Enum) { - html += ' = <span class="tok-number">' + field + '</span>'; + html += ' = <span class="tok-number">' + fieldName + '</span>'; } else { + let fieldTypeExpr = container.fields[i]; html += ": "; - if (typeof(field) === 'object') { - html += '<span class="tok-kw">var</span>'; - } else { - html += typeIndexName(field, true, true); + let name = exprName(fieldTypeExpr, false, false); + html += '<span class="tok-kw">'+ name +'</span>'; + let tsn = typeShorthandName(fieldTypeExpr); + if (tsn) { + html += '<span> ('+ tsn +')</span>'; + } } html += ',</pre></div>'; - var docs = fieldNode.docs; + let docs = fieldNode.docs; if (docs != null) { html += markdown(docs); } divDom.innerHTML = html; } - domListFields.innerHTML = ""; - domListFields.appendChild(domListFieldsFragment); domSectFields.classList.remove("hidden"); } if (varsList.length !== 0) { - var domListGlobalVarsFragment = createDomListFragment(varsList.length, + resizeDomList(domListGlobalVars, varsList.length, '<tr><td><a href="#"></a></td><td></td><td></td></tr>'); - for (var i = 0; i < varsList.length; i += 1) { - var decl = varsList[i]; - var trDom = domListGlobalVarsFragment.children[i]; + for (let i = 0; i < varsList.length; i += 1) { + let decl = varsList[i]; + let trDom = domListGlobalVars.children[i]; - var tdName = trDom.children[0]; - var tdNameA = tdName.children[0]; - var tdType = trDom.children[1]; - var tdDesc = trDom.children[2]; + let tdName = trDom.children[0]; + let tdNameA = tdName.children[0]; + let tdType = trDom.children[1]; + let tdDesc = trDom.children[2]; tdNameA.setAttribute('href', navLinkDecl(decl.name)); tdNameA.textContent = decl.name; - tdType.innerHTML = typeIndexName(decl.type, true, true); + tdType.innerHTML = typeValueName(typeOfDecl(decl), true, true); - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { tdDesc.innerHTML = shortDescMarkdown(docs); } else { tdDesc.textContent = ""; } } - domListGlobalVars.innerHTML = ""; - domListGlobalVars.appendChild(domListGlobalVarsFragment); domSectGlobalVars.classList.remove("hidden"); } if (valsList.length !== 0) { - var domListValuesFragment = createDomListFragment(valsList.length, + resizeDomList(domListValues, valsList.length, '<tr><td><a href="#"></a></td><td></td><td></td></tr>'); - for (var i = 0; i < valsList.length; i += 1) { - var decl = valsList[i]; - var trDom = domListValuesFragment.children[i]; + for (let i = 0; i < valsList.length; i += 1) { + let decl = valsList[i]; + let trDom = domListValues.children[i]; - var tdName = trDom.children[0]; - var tdNameA = tdName.children[0]; - var tdType = trDom.children[1]; - var tdDesc = trDom.children[2]; + let tdName = trDom.children[0]; + let tdNameA = tdName.children[0]; + let tdType = trDom.children[1]; + let tdDesc = trDom.children[2]; tdNameA.setAttribute('href', navLinkDecl(decl.name)); tdNameA.textContent = decl.name; - tdType.innerHTML = typeIndexName(decl.type, true, true); + tdType.innerHTML = exprName(walkResultTypeRef(decl.value), + {wantHtml:true, wantLink:true}); - var docs = zigAnalysis.astNodes[decl.src].docs; + let docs = zigAnalysis.astNodes[decl.src].docs; if (docs != null) { tdDesc.innerHTML = shortDescMarkdown(docs); } else { tdDesc.textContent = ""; } } - domListValues.innerHTML = ""; - domListValues.appendChild(domListValuesFragment); domSectValues.classList.remove("hidden"); } + + if (testsList.length !== 0) { + resizeDomList(domListTests, testsList.length, + '<tr><td><a href="#"></a></td><td></td><td></td></tr>'); + for (let i = 0; i < testsList.length; i += 1) { + let decl = testsList[i]; + let trDom = domListTests.children[i]; + + let tdName = trDom.children[0]; + let tdNameA = tdName.children[0]; + let tdType = trDom.children[1]; + let tdDesc = trDom.children[2]; + + tdNameA.setAttribute('href', navLinkDecl(decl.name)); + tdNameA.textContent = decl.name; + + tdType.innerHTML = exprName(walkResultTypeRef(decl.value), + {wantHtml:true, wantLink:true}); + + let docs = zigAnalysis.astNodes[decl.src].docs; + if (docs != null) { + tdDesc.innerHTML = shortDescMarkdown(docs); + } else { + tdDesc.textContent = ""; + } + } + domSectTests.classList.remove("hidden"); + } } + + function operatorCompare(a, b) { if (a === b) { return 0; @@ -1162,33 +2395,33 @@ } function detectRootIsStd() { - var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; + let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; if (rootPkg.table["std"] == null) { // no std mapped into the root package return false; } - var stdPkg = zigAnalysis.packages[rootPkg.table["std"]]; + let stdPkg = zigAnalysis.packages[rootPkg.table["std"]]; if (stdPkg == null) return false; return rootPkg.file === stdPkg.file; } function indexTypeKinds() { - var map = {}; - for (var i = 0; i < zigAnalysis.typeKinds.length; i += 1) { + let map = ({}); + for (let i = 0; i < zigAnalysis.typeKinds.length; i += 1) { map[zigAnalysis.typeKinds[i]] = i; } // This is just for debugging purposes, not needed to function - var assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct", + let assertList = ["Type","Void","Bool","NoReturn","Int","Float","Pointer","Array","Struct", "ComptimeFloat","ComptimeInt","Undefined","Null","Optional","ErrorUnion","ErrorSet","Enum", "Union","Fn","BoundFn","Opaque","Frame","AnyFrame","Vector","EnumLiteral"]; - for (var i = 0; i < assertList.length; i += 1) { + for (let i = 0; i < assertList.length; i += 1) { if (map[assertList[i]] == null) throw new Error("No type kind '" + assertList[i] + "' found"); } return map; } function findTypeTypeId() { - for (var i = 0; i < zigAnalysis.types.length; i += 1) { + for (let i = 0; i < zigAnalysis.types.length; i += 1) { if (zigAnalysis.types[i].kind == typeKinds.Type) { return i; } @@ -1197,17 +2430,26 @@ } function updateCurNav() { + curNav = { + showPrivDecls: false, pkgNames: [], pkgObjs: [], declNames: [], declObjs: [], + callName: null, }; curNavSearch = ""; if (location.hash[0] === '#' && location.hash.length > 1) { - var query = location.hash.substring(1); - var qpos = query.indexOf("?"); + let query = location.hash.substring(1); + if (query[0] === '*') { + curNav.showPrivDecls = true; + query = query.substring(1); + } + + let qpos = query.indexOf("?"); + let nonSearchPart; if (qpos === -1) { nonSearchPart = query; } else { @@ -1215,16 +2457,12 @@ curNavSearch = decodeURIComponent(query.substring(qpos + 1)); } - var parts = nonSearchPart.split(";"); + let parts = nonSearchPart.split(";"); curNav.pkgNames = decodeURIComponent(parts[0]).split("."); if (parts[1] != null) { curNav.declNames = decodeURIComponent(parts[1]).split("."); } } - - if (curNav.pkgNames.length === 0 && rootIsStd) { - curNav.pkgNames = ["std"]; - } } function onHashChange() { @@ -1239,43 +2477,65 @@ } } + function findSubDecl(parentType, childName) { - if (parentType.pubDecls == null) throw new Error("parent object has no public decls"); - for (var i = 0; i < parentType.pubDecls.length; i += 1) { - var declIndex = parentType.pubDecls[i]; - var childDecl = zigAnalysis.decls[declIndex]; + { + // Generic functions + if ("value" in parentType) { + const rv = resolveValue(parentType.value); + if ("type" in rv.expr) { + const t = zigAnalysis.types[rv.expr.type]; + if (t.kind == typeKinds.Fn && t.generic_ret != null) { + const rgr = resolveValue({expr: t.generic_ret}); + if ("type" in rgr.expr) { + parentType = zigAnalysis.types[rgr.expr.type]; + } + } + } + } + } + + + if (!parentType.pubDecls) return null; + for (let i = 0; i < parentType.pubDecls.length; i += 1) { + let declIndex = parentType.pubDecls[i]; + let childDecl = zigAnalysis.decls[declIndex]; if (childDecl.name === childName) { return childDecl; } } - return null; - } - - function getDeclContainerType(decl) { - if (decl.type === typeTypeId) { - return zigAnalysis.types[decl.value]; + if (!parentType.privDecls) return null; + for (let i = 0; i < parentType.privDecls.length; i += 1) { + let declIndex = parentType.privDecls[i]; + let childDecl = zigAnalysis.decls[declIndex]; + if (childDecl.name === childName) { + return childDecl; + } } return null; } + + + function computeCanonicalPackagePaths() { - var list = new Array(zigAnalysis.packages.length); + let list = new Array(zigAnalysis.packages.length); // Now we try to find all the packages from root. - var rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; + let rootPkg = zigAnalysis.packages[zigAnalysis.rootPkg]; // Breadth-first to keep the path shortest possible. - var stack = [{ - path: [], + let stack = [{ + path: ([]), pkg: rootPkg, }]; while (stack.length !== 0) { - var item = stack.shift(); - for (var key in item.pkg.table) { - var childPkgIndex = item.pkg.table[key]; + let item = (stack.shift()); + for (let key in item.pkg.table) { + let childPkgIndex = item.pkg.table[key]; if (list[childPkgIndex] != null) continue; - var childPkg = zigAnalysis.packages[childPkgIndex]; + let childPkg = zigAnalysis.packages[childPkgIndex]; if (childPkg == null) continue; - var newPath = item.path.concat([key]) + let newPath = item.path.concat([key]) list[childPkgIndex] = newPath; stack.push({ path: newPath, @@ -1286,53 +2546,68 @@ return list; } - function typeKindIsContainer(typeKind) { - return typeKind === typeKinds.Struct || - typeKind === typeKinds.Union || - typeKind === typeKinds.Enum; - } - - function declCanRepresentTypeKind(typeKind) { - return typeKind === typeKinds.ErrorSet || typeKindIsContainer(typeKind); - } + function computeCanonDeclPaths() { - var list = new Array(zigAnalysis.decls.length); + let list = new Array(zigAnalysis.decls.length); canonTypeDecls = new Array(zigAnalysis.types.length); - for (var pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) { + for (let pkgI = 0; pkgI < zigAnalysis.packages.length; pkgI += 1) { if (pkgI === zigAnalysis.rootPkg && rootIsStd) continue; - var pkg = zigAnalysis.packages[pkgI]; - var pkgNames = canonPkgPaths[pkgI]; - var stack = [{ - declNames: [], + let pkg = zigAnalysis.packages[pkgI]; + let pkgNames = canonPkgPaths[pkgI]; + if (pkgNames === undefined) continue; + + let stack = [{ + declNames: ([]), type: zigAnalysis.types[pkg.main], }]; while (stack.length !== 0) { - var item = stack.shift(); + let item = (stack.shift()); + + if (isContainerType(item.type)) { + let t = (item.type); - if (item.type.pubDecls != null) { - for (var declI = 0; declI < item.type.pubDecls.length; declI += 1) { - var mainDeclIndex = item.type.pubDecls[declI]; + let len = t.pubDecls ? t.pubDecls.length : 0; + for (let declI = 0; declI < len; declI += 1) { + let mainDeclIndex = t.pubDecls[declI]; if (list[mainDeclIndex] != null) continue; - var decl = zigAnalysis.decls[mainDeclIndex]; - if (decl.type === typeTypeId && - declCanRepresentTypeKind(zigAnalysis.types[decl.value].kind)) - { - canonTypeDecls[decl.value] = mainDeclIndex; - } - var declNames = item.declNames.concat([decl.name]); + let decl = zigAnalysis.decls[mainDeclIndex]; + let declVal = decl.value; //resolveValue(decl.value); + let declNames = item.declNames.concat([decl.name]); list[mainDeclIndex] = { pkgNames: pkgNames, declNames: declNames, }; - var containerType = getDeclContainerType(decl); - if (containerType != null) { - stack.push({ - declNames: declNames, - type: containerType, - }); + if ("type" in declVal.expr) { + let value = zigAnalysis.types[declVal.expr.type]; + if (declCanRepresentTypeKind(value.kind)) + { + canonTypeDecls[declVal.type] = mainDeclIndex; + } + + if (isContainerType(value)) { + stack.push({ + declNames: declNames, + type:value, + }); + } + + + // Generic function + if (value.kind == typeKinds.Fn && value.generic_ret != null) { + let resolvedVal = resolveValue({ expr: value.generic_ret}); + if ("type" in resolvedVal.expr) { + let generic_type = zigAnalysis.types[resolvedVal.expr.type]; + if (isContainerType(generic_type)){ + stack.push({ + declNames: declNames, + type: generic_type, + }); + } + } + } } } } @@ -1341,41 +2616,49 @@ return list; } + function getCanonDeclPath(index) { if (canonDeclPaths == null) { canonDeclPaths = computeCanonDeclPaths(); } + //let cd = (canonDeclPaths); return canonDeclPaths[index]; } + function getCanonTypeDecl(index) { getCanonDeclPath(0); + //let ct = (canonTypeDecls); return canonTypeDecls[index]; } + function escapeHtml(text) { return text.replace(/[&"<>]/g, function (m) { return escapeHtmlReplacements[m]; }); } + function shortDescMarkdown(docs) { - var parts = docs.trim().split("\n"); - var firstLine = parts[0]; + let parts = docs.trim().split("\n"); + let firstLine = parts[0]; return markdown(firstLine); } + function markdown(input) { const raw_lines = input.split('\n'); // zig allows no '\r', so we don't need to split on CR + const lines = []; // PHASE 1: // Dissect lines and determine the type for each line. - // Also computes indentation level and removes unnecessary whitespace + // Also computes indentation level and removes unnecessary whitespace - var is_reading_code = false; - var code_indent = 0; - for (var line_no = 0; line_no < raw_lines.length; line_no++) { + let is_reading_code = false; + let code_indent = 0; + for (let line_no = 0; line_no < raw_lines.length; line_no++) { const raw_line = raw_lines[line_no]; const line = { @@ -1383,6 +2666,7 @@ raw_text: raw_line, text: raw_line.trim(), type: "p", // p, h1 … h6, code, ul, ol, blockquote, skip, empty + ordered_number: -1, // NOTE: hack to make the type checker happy }; if (!is_reading_code) { @@ -1419,7 +2703,7 @@ line.text = line.text.substr(1); } else if (line.text.match(/^\d+\..*$/)) { // if line starts with {number}{dot} - const match = line.text.match(/(\d+)\./); + const match = (line.text.match(/(\d+)\./)); line.type = "ul"; line.text = line.text.substr(match[0].length); line.ordered_number = Number(match[1].length); @@ -1450,21 +2734,24 @@ // PHASE 2: // Render HTML from markdown lines. - // Look at each line and emit fitting HTML code + // Look at each line and emit fitting HTML code - function markdownInlines(innerText, stopChar) { + + function markdownInlines(innerText) { // inline types: // **{INLINE}** : <strong> - // __{INLINE}__ : <u> - // ~~{INLINE}~~ : <s> - // *{INLINE}* : <emph> - // _{INLINE}_ : <emph> - // `{TEXT}` : <code> - // [{INLINE}]({URL}) : <a> - //  : <img> - // [[std;format.fmt]] : <a> (inner link) - + // __{INLINE}__ : <u> + // ~~{INLINE}~~ : <s> + // *{INLINE}* : <emph> + // _{INLINE}_ : <emph> + // `{TEXT}` : <code> + // [{INLINE}]({URL}) : <a> + //  : <img> + // [[std;format.fmt]] : <a> (inner link) + + + const formats = [ { marker: "**", @@ -1484,26 +2771,11 @@ } ]; - // Links, images and inner links don't use the same marker to wrap their content. - const linksFormat = [ - { - prefix: "[", - regex: /\[([^\]]*)\]\(([^\)]*)\)/, - urlIndex: 2, // Index in the match that contains the link URL - textIndex: 1 // Index in the match that contains the link text - }, - { - prefix: "h", - regex: /http[s]?:\/\/[^\s]+/, - urlIndex: 0, - textIndex: 0 - } - ]; - + const stack = []; - var innerHTML = ""; - var currentRun = ""; + let innerHTML = ""; + let currentRun = ""; function flushRun() { if (currentRun != "") { @@ -1512,18 +2784,18 @@ currentRun = ""; } - var parsing_code = false; - var codetag = ""; - var in_code = false; + let parsing_code = false; + let codetag = ""; + let in_code = false; - for (var i = 0; i < innerText.length; i++) { + for (let i = 0; i < innerText.length; i++) { if (parsing_code && in_code) { if (innerText.substr(i, codetag.length) == codetag) { // remove leading and trailing whitespace if string both starts and ends with one. - if (currentRun[0] == " " && currentRun[currentRun.length - 1] == " ") { - currentRun = currentRun.substr(1, currentRun.length - 2); - } + if (currentRun[0] == " " && currentRun[currentRun.length - 1] == " ") { + currentRun = currentRun.substr(1, currentRun.length - 2); + } flushRun(); i += codetag.length - 1; in_code = false; @@ -1550,31 +2822,8 @@ currentRun += innerText[i]; in_code = true; } else { - var foundMatches = false; - - for (var j = 0; j < linksFormat.length; j++) { - const linkFmt = linksFormat[j]; - - if (linkFmt.prefix == innerText[i]) { - var remaining = innerText.substring(i); - var matches = remaining.match(linkFmt.regex); - - if (matches) { - flushRun(); - innerHTML += ' <a href="' + matches[linkFmt.urlIndex] + '">' + matches[linkFmt.textIndex] + '</a> '; - i += matches[0].length; // Skip the fragment we just consumed - foundMatches = true; - break; - } - } - } - - if (foundMatches) { - continue; - } - - var any = false; - for (var idx = (stack.length > 0 ? -1 : 0); idx < formats.length; idx++) { + let any = false; + for (let idx = (stack.length > 0 ? -1 : 0); idx < formats.length; idx++) { const fmt = idx >= 0 ? formats[idx] : stack[stack.length - 1]; if (innerText.substr(i, fmt.marker.length) == fmt.marker) { flushRun(); @@ -1598,48 +2847,54 @@ flushRun(); while (stack.length > 0) { - const fmt = stack.pop(); + const fmt = (stack.pop()); innerHTML += "</" + fmt.tag + ">"; } return innerHTML; } - var html = ""; - for (var line_no = 0; line_no < lines.length; line_no++) { - const line = lines[line_no]; - - function previousLineIs(type) { - if (line_no > 0) { - return (lines[line_no - 1].type == type); - } else { - return false; - } + + function previousLineIs(type, line_no) { + if (line_no > 0) { + return (lines[line_no - 1].type == type); + } else { + return false; } + } - function nextLineIs(type) { - if (line_no < (lines.length - 1)) { - return (lines[line_no + 1].type == type); - } else { - return false; - } + + function nextLineIs(type, line_no) { + if (line_no < (lines.length - 1)) { + return (lines[line_no + 1].type == type); + } else { + return false; } + } - function getPreviousLineIndent() { - if (line_no > 0) { - return lines[line_no - 1].indent; - } else { - return 0; - } + + function getPreviousLineIndent(line_no) { + if (line_no > 0) { + return lines[line_no - 1].indent; + } else { + return 0; } + } - function getNextLineIndent() { - if (line_no < (lines.length - 1)) { - return lines[line_no + 1].indent; - } else { - return 0; - } + + function getNextLineIndent(line_no) { + if (line_no < (lines.length - 1)) { + return lines[line_no + 1].indent; + } else { + return 0; } + } + + let html = ""; + for (let line_no = 0; line_no < lines.length; line_no++) { + const line = lines[line_no]; + + switch (line.type) { case "h1": @@ -1653,33 +2908,33 @@ case "ul": case "ol": - if (!previousLineIs("ul") || getPreviousLineIndent() < line.indent) { + if (!previousLineIs("ul", line_no) || getPreviousLineIndent(line_no) < line.indent) { html += "<" + line.type + ">\n"; } html += "<li>" + markdownInlines(line.text) + "</li>\n"; - if (!nextLineIs("ul") || getNextLineIndent() < line.indent) { + if (!nextLineIs("ul", line_no) || getNextLineIndent(line_no) < line.indent) { html += "</" + line.type + ">\n"; } break; case "p": - if (!previousLineIs("p")) { + if (!previousLineIs("p", line_no)) { html += "<p>\n"; } html += markdownInlines(line.text) + "\n"; - if (!nextLineIs("p")) { + if (!nextLineIs("p", line_no)) { html += "</p>\n"; } break; case "code": - if (!previousLineIs("code")) { + if (!previousLineIs("code", line_no)) { html += "<pre><code>"; } html += escapeHtml(line.text) + "\n"; - if (!nextLineIs("code")) { + if (!nextLineIs("code", line_no)) { html += "</code></pre>\n"; } break; @@ -1694,26 +2949,27 @@ return; } - var liDom = domListSearchResults.children[curSearchIndex]; + let liDom = domListSearchResults.children[curSearchIndex]; if (liDom == null && domListSearchResults.children.length !== 0) { liDom = domListSearchResults.children[0]; } if (liDom != null) { - var aDom = liDom.children[0]; - location.href = aDom.getAttribute("href"); + let aDom = liDom.children[0]; + location.href = (aDom.getAttribute("href")); curSearchIndex = -1; } domSearch.blur(); } + function onSearchKeyDown(ev) { switch (getKeyString(ev)) { case "Enter": // detect if this search changes anything - var terms1 = getSearchTerms(); + let terms1 = getSearchTerms(); startSearch(); updateCurNav(); - var terms2 = getSearchTerms(); + let terms2 = getSearchTerms(); // we might have to wait for onHashChange to trigger imFeelingLucky = (terms1.join(' ') !== terms2.join(' ')); if (!imFeelingLucky) activateSelectedResult(); @@ -1749,6 +3005,8 @@ } } + + function moveSearchCursor(dir) { if (curSearchIndex < 0 || curSearchIndex >= domListSearchResults.children.length) { if (dir > 0) { @@ -1768,9 +3026,10 @@ renderSearchCursor(); } + function getKeyString(ev) { - var name; - var ignoreShift = false; + let name; + let ignoreShift = false; switch (ev.which) { case 13: name = "Enter"; @@ -1794,6 +3053,7 @@ return name; } + function onWindowKeyDown(ev) { switch (getKeyString(ev)) { case "Esc": @@ -1811,214 +3071,160 @@ startAsyncSearch(); break; case "?": - ev.preventDefault(); + ev.preventDefault(); ev.stopPropagation(); showHelpModal(); break; } } - function showHelpModal() { - domHelpModal.classList.remove("hidden"); - domHelpModal.style.left = (window.innerWidth / 2 - domHelpModal.clientWidth / 2) + "px"; - domHelpModal.style.top = (window.innerHeight / 2 - domHelpModal.clientHeight / 2) + "px"; - domHelpModal.focus(); - } - - function onClickSearchShowAllResults(ev) { - ev.preventDefault(); - ev.stopPropagation(); - searchTrimResults = false; - onHashChange(); - } - - function clearAsyncSearch() { - if (searchTimer != null) { - clearTimeout(searchTimer); - searchTimer = null; - } - } - - function startAsyncSearch() { - clearAsyncSearch(); - searchTrimResults = true; - searchTimer = setTimeout(startSearch, 10); - } - function startSearch() { - clearAsyncSearch(); - var oldHash = location.hash; - var parts = oldHash.split("?"); - var newPart2 = (domSearch.value === "") ? "" : ("?" + domSearch.value); - var newHash = (oldHash === "" ? "#" : parts[0]) + newPart2; - // create a history entry only once per search - if (parts.length === 1) { - location.assign(newHash); - } else { - location.replace(newHash); - } - } - function getSearchTerms() { - var list = curNavSearch.trim().split(/[ \r\n\t]+/); - list.sort(); - return list; - } - function renderSearch() { - var matchedItems = []; - var ignoreCase = (curNavSearch.toLowerCase() === curNavSearch); - var terms = getSearchTerms(); - - decl_loop: for (var declIndex = 0; declIndex < zigAnalysis.decls.length; declIndex += 1) { - var canonPath = getCanonDeclPath(declIndex); - if (canonPath == null) continue; - - var decl = zigAnalysis.decls[declIndex]; - var lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1]; - var fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.'); - var astNode = zigAnalysis.astNodes[decl.src]; - var fileAndDocs = zigAnalysis.files[astNode.file]; - if (astNode.docs != null) { - fileAndDocs += "\n" + astNode.docs; - } - var fullPathSearchTextLower = fullPathSearchText; - if (ignoreCase) { - fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase(); - fileAndDocs = fileAndDocs.toLowerCase(); - } - - var points = 0; - for (var termIndex = 0; termIndex < terms.length; termIndex += 1) { - var term = terms[termIndex]; - - // exact, case sensitive match of full decl path - if (fullPathSearchText === term) { - points += 4; - continue; - } - // exact, case sensitive match of just decl name - if (decl.name == term) { - points += 3; - continue; - } - // substring, case insensitive match of full decl path - if (fullPathSearchTextLower.indexOf(term) >= 0) { - points += 2; - continue; - } - if (fileAndDocs.indexOf(term) >= 0) { - points += 1; - continue; - } - - continue decl_loop; +function showHelpModal() { + domHelpModal.classList.remove("hidden"); + domHelpModal.style.left = (window.innerWidth / 2 - domHelpModal.clientWidth / 2) + "px"; + domHelpModal.style.top = (window.innerHeight / 2 - domHelpModal.clientHeight / 2) + "px"; + domHelpModal.focus(); +} + +function clearAsyncSearch() { + if (searchTimer != null) { + clearTimeout(searchTimer); + searchTimer = null; + } +} + +function startAsyncSearch() { + clearAsyncSearch(); + searchTimer = setTimeout(startSearch, 100); +} +function startSearch() { + clearAsyncSearch(); + let oldHash = location.hash; + let parts = oldHash.split("?"); + let newPart2 = (domSearch.value === "") ? "" : ("?" + domSearch.value); + location.hash = (parts.length === 1) ? (oldHash + newPart2) : (parts[0] + newPart2); +} +function getSearchTerms() { + let list = curNavSearch.trim().split(/[ \r\n\t]+/); + list.sort(); + return list; +} +function renderSearch() { + let matchedItems = []; + let ignoreCase = (curNavSearch.toLowerCase() === curNavSearch); + let terms = getSearchTerms(); + + decl_loop: for (let declIndex = 0; declIndex < zigAnalysis.decls.length; declIndex += 1) { + let canonPath = getCanonDeclPath(declIndex); + if (canonPath == null) continue; + + let decl = zigAnalysis.decls[declIndex]; + let lastPkgName = canonPath.pkgNames[canonPath.pkgNames.length - 1]; + let fullPathSearchText = lastPkgName + "." + canonPath.declNames.join('.'); + let astNode = zigAnalysis.astNodes[decl.src]; + let fileAndDocs = "" //zigAnalysis.files[astNode.file]; + // TODO: understand what this piece of code is trying to achieve + // also right now `files` are expressed as a hashmap. + if (astNode.docs != null) { + fileAndDocs += "\n" + astNode.docs; + } + let fullPathSearchTextLower = fullPathSearchText; + if (ignoreCase) { + fullPathSearchTextLower = fullPathSearchTextLower.toLowerCase(); + fileAndDocs = fileAndDocs.toLowerCase(); + } + + let points = 0; + for (let termIndex = 0; termIndex < terms.length; termIndex += 1) { + let term = terms[termIndex]; + + // exact, case sensitive match of full decl path + if (fullPathSearchText === term) { + points += 4; + continue; + } + // exact, case sensitive match of just decl name + if (decl.name == term) { + points += 3; + continue; + } + // substring, case insensitive match of full decl path + if (fullPathSearchTextLower.indexOf(term) >= 0) { + points += 2; + continue; + } + if (fileAndDocs.indexOf(term) >= 0) { + points += 1; + continue; } - matchedItems.push({ - decl: decl, - path: canonPath, - points: points, - }); + continue decl_loop; } - if (matchedItems.length !== 0) { - matchedItems.sort(function(a, b) { - var cmp = operatorCompare(b.points, a.points); - if (cmp != 0) return cmp; - return operatorCompare(a.decl.name, b.decl.name); - }); + matchedItems.push({ + decl: decl, + path: canonPath, + points: points, + }); + } - var searchTrimmed = false - var searchTrimResultsMaxItems = 200 - if (searchTrimResults && matchedItems.length > searchTrimResultsMaxItems) { - matchedItems = matchedItems.slice(0, searchTrimResultsMaxItems) - searchTrimmed = true - } + if (matchedItems.length !== 0) { + resizeDomList(domListSearchResults, matchedItems.length, '<li><a href="#"></a></li>'); - var domListSearchResultsFragment = createDomListFragment(matchedItems.length, '<li><a href="#"></a></li>'); - for (var i = 0; i < matchedItems.length; i += 1) { - var liDom = domListSearchResultsFragment.children[i]; - var aDom = liDom.children[0]; - var match = matchedItems[i]; - var lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1]; - aDom.textContent = lastPkgName + "." + match.path.declNames.join('.'); - aDom.setAttribute('href', navLink(match.path.pkgNames, match.path.declNames)); - } + matchedItems.sort(function(a, b) { + let cmp = operatorCompare(b.points, a.points); + if (cmp != 0) return cmp; + return operatorCompare(a.decl.name, b.decl.name); + }); - domListSearchResults.innerHTML = ""; - domListSearchResults.appendChild(domListSearchResultsFragment); - domSectSearchResults.classList.remove("hidden"); + for (let i = 0; i < matchedItems.length; i += 1) { + let liDom = domListSearchResults.children[i]; + let aDom = liDom.children[0]; + let match = matchedItems[i]; + let lastPkgName = match.path.pkgNames[match.path.pkgNames.length - 1]; + aDom.textContent = lastPkgName + "." + match.path.declNames.join('.'); + aDom.setAttribute('href', navLink(match.path.pkgNames, match.path.declNames)); + } + renderSearchCursor(); - if (searchTrimmed) { - domSectSearchAllResultsLink.classList.remove("hidden"); - } + domSectSearchResults.classList.remove("hidden"); + } else { + domSectSearchNoResults.classList.remove("hidden"); + } +} - renderSearchCursor(); +function renderSearchCursor() { + for (let i = 0; i < domListSearchResults.children.length; i += 1) { + let liDom = (domListSearchResults.children[i]); + if (curSearchIndex === i) { + liDom.classList.add("selected"); } else { - domSectSearchNoResults.classList.remove("hidden"); + liDom.classList.remove("selected"); } } +} - function renderSearchCursor() { - for (var i = 0; i < domListSearchResults.children.length; i += 1) { - var liDom = domListSearchResults.children[i]; - if (curSearchIndex === i) { - liDom.classList.add("selected"); - } else { - liDom.classList.remove("selected"); - } - } - } - function indexNodesToFns() { - var map = {}; - for (var i = 0; i < zigAnalysis.fns.length; i += 1) { - var fn = zigAnalysis.fns[i]; - if (typeIsGenericFn(fn.type)) continue; - if (map[fn.src] == null) { - map[fn.src] = [i]; - } else { - map[fn.src].push(i); - } - } - return map; - } - function indexNodesToCalls() { - var map = {}; - for (var i = 0; i < zigAnalysis.calls.length; i += 1) { - var call = zigAnalysis.calls[i]; - var fn = zigAnalysis.fns[call.fn]; - if (map[fn.src] == null) { - map[fn.src] = [i]; - } else { - map[fn.src].push(i); - } - } - return map; - } +// function indexNodesToCalls() { +// let map = {}; +// for (let i = 0; i < zigAnalysis.calls.length; i += 1) { +// let call = zigAnalysis.calls[i]; +// let fn = zigAnalysis.fns[call.fn]; +// if (map[fn.src] == null) { +// map[fn.src] = [i]; +// } else { +// map[fn.src].push(i); +// } +// } +// return map; +// } - function byNameProperty(a, b) { - return operatorCompare(a.name, b.name); - } - function clone(obj) { - var res = {}; - for (var key in obj) { - res[key] = obj[key]; - } - return res; - } - function firstObjectKey(obj) { - for (var key in obj) { - return key; - } - } +function byNameProperty(a, b) { + return operatorCompare(a.name, b.name); +} + + - function token(value, tokenClass, wantHtml){ - if(wantHtml){ - return '<span class="' + tokenClass + '">' + value + '</span>'; - } else { - return value + ''; - } - } })(); |